Hi all,

First question: using nmap 10.101.40.200 shows port 53 and dns running
so why would DirContext.list() throw "OperationNotSupportedException:
DNS service refused" ? The goal: Find all hosts that are known to a
nameserver. If one of the hosts is a NS record, search that server as
well.  I can switch - as the commented out code shows - to use the
public dns server via calculateDNS("bee.uspnet.usp.br", "usp.br") and
the code works fine. Why I can't connect to 10.101.40.200 completely
baffles me - what exactly is DirContext.list() trying to look for in
the DNS service ? I tried DNSJava as well with the same problem.

Second question: Can someone explain the equivalent DIG or NSLOOKUP
commands that and the subsequent:

NamingEnumeration hostEnumeration = DirContext.list()
String host = ((NameClassPair) hostEnumeration.next())
                             .getNameInNamespace();

I want to post the DNS parts of the question to the approriate
newsgroup, but I'm having a hard time using DIG and NSLOOKUP to repeat
the results.

Here's my code - there are a few sockets open, already cancelled,
waiting to timeout which is ok. Not sure about the recursion part -
still thinking about it.

package org;

import java.util.concurrent.*;

public class RecursionLatch {
   private final CountDownLatch done = new CountDownLatch(1);

   public boolean isSet() {
       return (done.getCount() == 0);
   }

   public synchronized void setCompleted() {
       if (!isSet()) {
           done.countDown();
       }
   }

   public void taskCompleted() throws InterruptedException {
       done.await();
   }
}

package org;

import static java.lang.System.out;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Hashtable;
import java.util.List;
import java.util.Queue;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.Callable;
import java.util.concurrent.Future;
import java.util.concurrent.atomic.AtomicInteger;

import javax.naming.NameClassPair;
import javax.naming.NamingEnumeration;
import javax.naming.directory.Attributes;
import javax.naming.directory.DirContext;
import javax.naming.directory.InitialDirContext;
import javax.naming.directory.Attribute;
import javax.naming.directory.Attributes;
import javax.naming.NamingException;

public class DNS
{
 private static final AtomicInteger taskCount = new AtomicInteger(0);
 private static final RecursionLatch solution = new RecursionLatch();

 public static void main(String[] args) throws Exception {
     helloDNS();
 }

 /*******************************************************************
 Use this method to test dns
 *******************************************************************/
 private static void helloDNS() throws Exception {
      //calculateDNS("10.101.40.200", "atlantico.com.br");
      calculateDNS("bee.uspnet.usp.br", "usp.br");
      out.println("calculateDNS returned, waiting for cancelled
sockets to timeout...");
 }

 private static List<String> calculateDNS(final String ipDNS, final
String domain)
         throws Exception {

     final Hashtable<String, String> env = new Hashtable<String,
String>();
     env.put("java.naming.factory.initial",
"com.sun.jndi.dns.DnsContextFactory");
     env.put("java.naming.provider.url", "dns://" + ipDNS + "/");

     final DirContext ictx;
     ictx = new InitialDirContext(env);
     ExecutorService exec = Executors.newCachedThreadPool();

     NamingEnumeration hostEnumeration = null;
     boolean gotList = false;
     Callable <NamingEnumeration> listTask =
         new Callable<NamingEnumeration>() {
             public NamingEnumeration call() {
                 try {
                     return ictx.list(domain);
                 } catch (Exception ex) {
                     ex.printStackTrace();
                 }
                 return null;
             }
         };
     Future <NamingEnumeration> future = exec.submit(listTask);
     try {
         hostEnumeration = future.get(10L, TimeUnit.SECONDS);
         if (hostEnumeration != null) {
             gotList = true;
         }
     } catch (Exception ex) {
         ex.printStackTrace();
     } finally {
         future.cancel(true);
     }

     try {
         if (!gotList) {
             throw new Exception("Can't connect to DNS server");
         }
         // skip those already found
         Queue <String> domainsVisitedQueue = new
ConcurrentLinkedQueue<String>();
         domainsVisitedQueue.add(domain);

         Queue <String> resultQueue = new
ConcurrentLinkedQueue<String>();
         parallelRecursiveDNS(exec, ictx, hostEnumeration,
domainsVisitedQueue, resultQueue );
         // wait for latch
         solution.taskCompleted();
         out.println("latch returned, waiting for shutdown");

         for (String s : resultQueue) {
             out.println("WTF: " + s);
         }
         return new ArrayList<String>(resultQueue);
     } catch (Exception ex) {
         ex.printStackTrace();
         throw new Exception (ex);
     } finally {
         out.println("shutting down DirContext");
         long ictxStart = System.currentTimeMillis();
         if (ictx != null) {
             try {
                 ictx.close();
             } catch (NamingException ex) {
                 ex.printStackTrace();
             }
         }
         long ictxEnd = System.currentTimeMillis();
         out.println("runnable execution time was "
           + (ictxStart - ictxStart) / 1000 + " seconds ");
         // may have some sockets still open that have been cancelled
- that's ok
         exec.shutdownNow();
         out.println("termination complete");
     }

 }

 private static void parallelRecursiveDNS(final ExecutorService exec,
final DirContext ictx,
         final NamingEnumeration hostEnumeration, final
Collection<String> domainsVisitedQueue,
         final Collection<String> results)
     throws Exception {

     while (hostEnumeration.hasMore()) {

         taskCount.incrementAndGet();
         exec.execute(new Runnable() {
             public void run() {
                 long runStart = System.currentTimeMillis();
                 try {
                     String host = null;
                     host = ((NameClassPair) hostEnumeration.next())
                             .getNameInNamespace();
                     if (results.contains(host)) {
                         return;
                     }
                     results.add(host);
                     out.println("Found host: " + host);
                     Attributes aDNS = ictx.getAttributes(host,
                                 new String[] { "NS" });
                     NamingEnumeration allDNS = aDNS.getAll();
                     while (allDNS.hasMore()) {
                         out.println("Entering allDNS: ");
                         Attribute attr = (Attribute) allDNS.next();
                         NamingEnumeration values = attr.getAll();
                         final String dns = values.next().toString();
                         if (domainsVisitedQueue.contains(dns)) {
                             continue;
                         }
                         domainsVisitedQueue.add(dns);

                         NamingEnumeration newEnumeration = null;
                         boolean gotList = false;
                         Callable <NamingEnumeration> listTask =
                             new Callable<NamingEnumeration>() {
                                 public NamingEnumeration call() {
                                     try {
                                         out.println("doing future on
ictx.list()");
                                         return ictx.list(dns);
                                     } catch (Exception ex) {
                                         ex.printStackTrace();
                                     }
                                     return null;
                                 }
                             };
                         Future <NamingEnumeration> future =
exec.submit(listTask);
                         try {
                             newEnumeration = future.get(10L,
TimeUnit.SECONDS);
                             if (newEnumeration != null) {
                                 gotList = true;
                             }
                         } catch (Exception ex) {
                             ex.printStackTrace();
                         } finally {
                             future.cancel(true);
                         }
                         if (!gotList) {
                             continue;
                         }
                         parallelRecursiveDNS(exec, ictx,
newEnumeration, domainsVisitedQueue, results);
                     }
                 } catch (Exception ex) {
                     ex.printStackTrace();
                 } finally {
                     long runEnd = System.currentTimeMillis();
                     out.println("runnable execution time was "
                       + (runEnd - runStart) / 1000 + " seconds ");
                     if (taskCount.decrementAndGet() == 0) {
                         out.println("\n\nparallelRecursiveDNS
finished\n\n");
                         solution.setCompleted();
                     }
                 }

             }
         });
     }
 }
}