jdk-sandbox: comparison src/jdk.dns.client/share/classes/jdk/dns/client/internal/DnsClient.java

equal deleted inserted replaced

-:027e4cb87353
+:465a15dd6bed
 package jdk.dns.client.internal;
 import jdk.dns.client.ex.DnsCommunicationException;
 import jdk.dns.client.ex.DnsNameNotFoundException;
-import jdk.dns.client.ex.DnsOperationNotSupportedException;
 import jdk.dns.client.ex.DnsResolverException;
-import jdk.dns.client.ex.DnsServiceUnavailableException;
+import java.io.BufferedInputStream;
+import java.io.BufferedOutputStream;
 import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
 import java.net.DatagramPacket;
 import java.net.InetAddress;
 import java.net.InetSocketAddress;
 import java.net.Socket;
 import java.net.SocketTimeoutException;
 import java.nio.channels.DatagramChannel;
 import java.security.AccessController;
 import java.security.PrivilegedAction;
 import java.security.SecureRandom;
 import java.util.ArrayList;
-import java.util.Collection;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.concurrent.locks.ReentrantLock;
 private List<Integer> serverPorts;
 private int timeout;                // initial timeout on UDP and TCP queries in ms
 private int retries;                // number of UDP retries
 private static final SecureRandom random;
 static {
 var pa = (PrivilegedAction<SecureRandom>) () -> JCAUtil.getSecureRandom();
 random = System.getSecurityManager() == null ? pa.run()
 * Each server is of the form "server[:port]".  IPv6 literal host names
 * include delimiting brackets.
 * "timeout" is the initial timeout interval (in ms) for queries,
 * and "retries" gives the number of retries per server.
 */
-public DnsClient(List<String> servers, int timeout, int retries)
+public DnsClient(List<String> servers, int timeout, int retries) {
-throws UnknownHostException {
 this.timeout = timeout;
 this.retries = retries;
 var serversList = new ArrayList<InetAddress>();
 var serverPortsList = new ArrayList<Integer>();
-for (String serverString:servers) {
+for (String serverString : servers) {
 // Is optional port given?
 int colon = serverString.indexOf(':',
 serverString.indexOf(']') + 1);
 return null;
 };
 byte[] addr = System.getSecurityManager() == null ?
 pa.run() : AccessController.doPrivileged(pa);
 if (addr != null) {
-serversList.add(InetAddress.getByAddress(server, addr));
+try {
-serverPortsList.add(serverPort);
+serversList.add(InetAddress.getByAddress(server, addr));
+serverPortsList.add(serverPort);
+} catch (UnknownHostException e) {
+// Malformed IP address is specified - will ignore it
+}
 }
 }
 this.servers = Collections.unmodifiableList(serversList);
 this.serverPorts = Collections.unmodifiableList(serverPortsList);
 reqs = Collections.synchronizedMap(
 }
 }
 Header hdr = new Header(msg, msg.length);
 if (auth && !hdr.authoritative) {
-caughtException = new DnsNameNotFoundException(
+caughtException = new DnsResolverException("DNS response not authoritative");
-"DNS response not authoritative");
 doNotRetry[i] = true;
 continue;
 }
 if (hdr.truncated) {  // message is truncated -- try TCP
 } finally {
 tcp.close();
 }
 Header hdr2 = new Header(msg2, msg2.length);
 if (hdr2.query) {
-throw new DnsCommunicationException(
+throw new DnsResolverException(
 "DNS error: expecting response");
 }
 checkResponseCode(hdr2);
 if (!auth || hdr2.authoritative) {
 try (DatagramChannel dc = getDatagramChannel()) {
 DatagramPacket opkt = new DatagramPacket(pkt.getData(), pkt.length(), server, port);
 DatagramPacket ipkt = new DatagramPacket(new byte[8000], 8000);
 // Packets may only be sent to or received from this server address
 // TODO: Revisit
-var pa = (PrivilegedAction<Void>) () -> {dc.socket().connect(server, port); return null;};
+var pa = (PrivilegedAction<Void>) () -> {
+dc.socket().connect(server, port);
+return null;
+};
 if (System.getSecurityManager() == null) {
 pa.run();
 } else {
 AccessController.doPrivileged(pa);
 }
 int qnameLen = fqdn.getOctets();
 int pktLen = DNS_HDR_SIZE + qnameLen + 4;
 Packet pkt = new Packet(pktLen);
 short flags = recursion ? Header.RD_BIT : 0;
+// flags = (short) (flags | Header.CD_BIT | Header.AD_BIT);
 pkt.putShort(xid, IDENT_OFFSET);
 pkt.putShort(flags, FLAGS_OFFSET);
 pkt.putShort(1, NUMQ_OFFSET);
 pkt.putShort(0, NUMANS_OFFSET);
 private boolean isMatchResponse(byte[] pkt, int xid)
 throws DnsResolverException {
 Header hdr = new Header(pkt, pkt.length);
 if (hdr.query) {
-throw new DnsCommunicationException("DNS error: expecting response");
+throw new DnsResolverException("DNS error: expecting response");
 }
 if (!reqs.containsKey(xid)) { // already received, ignore the response
 return false;
 }
 int qclass = query.getRrclass();
 DnsName qname = query.getName();
 // Check that the type/class/name in the query section of the
 // response match those in the original query
-if ((qtype == ResourceRecord.QTYPE_STAR ||
+if ((qtype == ResourceRecord.TYPE_ANY ||
 qtype == rr.getType()) &&
 (qclass == ResourceRecord.QCLASS_STAR ||
 qclass == rr.getRrclass()) &&
 qname.equals(rr.getName())) {
 String msg = (rcode < rcodeDescription.length)
 ? rcodeDescription[rcode]
 : "DNS error";
 msg += " [response code " + rcode + "]";
+throw new DnsResolverException(msg);
-switch (rcode) {
-case SERVER_FAILURE:
-throw new DnsServiceUnavailableException(msg);
-case NAME_ERROR:
-throw new DnsNameNotFoundException(msg);
-case NOT_IMPL:
-case REFUSED:
-throw new DnsOperationNotSupportedException(msg);
-case FORMAT_ERROR:
-default:
-throw new DnsResolverException(msg);
-}
 }
 //-------------------------------------------------------------------------
 private static final boolean DEBUG = java.security.AccessController.doPrivileged(
 }
 class Tcp {
 private final Socket sock;
-private final java.io.InputStream in;
+private final InputStream in;
-final java.io.OutputStream out;
+final OutputStream out;
 private int timeoutLeft;
 Tcp(InetAddress server, int port, int timeout) throws IOException {
 sock = new Socket();
 try {
 timeoutLeft = (int) (timeout - (System.currentTimeMillis() - start));
 if (timeoutLeft <= 0)
 throw new SocketTimeoutException();
 sock.setTcpNoDelay(true);
-out = new java.io.BufferedOutputStream(sock.getOutputStream());
+out = new BufferedOutputStream(sock.getOutputStream());
-in = new java.io.BufferedInputStream(sock.getInputStream());
+in = new BufferedInputStream(sock.getInputStream());
 } catch (Exception e) {
 try {
 sock.close();
 } catch (IOException ex) {
 e.addSuppressed(ex);

branch	aefimov-dns-client-branch
changeset 58971	465a15dd6bed
parent 58870	35c438a6d45c
child 59101	258033faefc9