DNS.java
上传用户:quxuerui
上传日期:2018-01-08
资源大小:41811k
文件大小:7k
源码类别:

网格计算

开发平台:

Java

  1. /**
  2.  * Licensed to the Apache Software Foundation (ASF) under one
  3.  * or more contributor license agreements.  See the NOTICE file
  4.  * distributed with this work for additional information
  5.  * regarding copyright ownership.  The ASF licenses this file
  6.  * to you under the Apache License, Version 2.0 (the
  7.  * "License"); you may not use this file except in compliance
  8.  * with the License.  You may obtain a copy of the License at
  9.  *
  10.  *     http://www.apache.org/licenses/LICENSE-2.0
  11.  *
  12.  * Unless required by applicable law or agreed to in writing, software
  13.  * distributed under the License is distributed on an "AS IS" BASIS,
  14.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15.  * See the License for the specific language governing permissions and
  16.  * limitations under the License.
  17.  */
  18. package org.apache.hadoop.net;
  19. import java.net.InetAddress;
  20. import java.net.NetworkInterface;
  21. import java.net.SocketException;
  22. import java.net.UnknownHostException;
  23. import java.util.Enumeration;
  24. import java.util.Vector;
  25. import javax.naming.NamingException;
  26. import javax.naming.directory.Attributes;
  27. import javax.naming.directory.DirContext;
  28. import javax.naming.directory.InitialDirContext;
  29. /**
  30.  * 
  31.  * A class that provides direct and reverse lookup functionalities, allowing
  32.  * the querying of specific network interfaces or nameservers.
  33.  * 
  34.  * 
  35.  */
  36. public class DNS {
  37.   /**
  38.    * Returns the hostname associated with the specified IP address by the
  39.    * provided nameserver.
  40.    * 
  41.    * @param hostIp
  42.    *            The address to reverse lookup
  43.    * @param ns
  44.    *            The host name of a reachable DNS server
  45.    * @return The host name associated with the provided IP
  46.    * @throws NamingException
  47.    *             If a NamingException is encountered
  48.    */
  49.   public static String reverseDns(InetAddress hostIp, String ns)
  50.     throws NamingException {
  51.     //
  52.     // Builds the reverse IP lookup form
  53.     // This is formed by reversing the IP numbers and appending in-addr.arpa
  54.     //
  55.     String[] parts = hostIp.getHostAddress().split("\.");
  56.     String reverseIP = parts[3] + "." + parts[2] + "." + parts[1] + "."
  57.       + parts[0] + ".in-addr.arpa";
  58.     DirContext ictx = new InitialDirContext();
  59.     Attributes attribute =
  60.       ictx.getAttributes("dns://"               // Use "dns:///" if the default
  61.                          + ((ns == null) ? "" : ns) + 
  62.                          // nameserver is to be used
  63.                          "/" + reverseIP, new String[] { "PTR" });
  64.     ictx.close();
  65.     
  66.     return attribute.get("PTR").get().toString();
  67.   }
  68.   /**
  69.    * Returns all the IPs associated with the provided interface, if any, in
  70.    * textual form.
  71.    * 
  72.    * @param strInterface
  73.    *            The name of the network interface to query (e.g. eth0)
  74.    * @return A string vector of all the IPs associated with the provided
  75.    *         interface
  76.    * @throws UnknownHostException
  77.    *             If an UnknownHostException is encountered in querying the
  78.    *             default interface
  79.    * 
  80.    */
  81.   public static String[] getIPs(String strInterface)
  82.     throws UnknownHostException {
  83.     try {
  84.       NetworkInterface netIF = NetworkInterface.getByName(strInterface);
  85.       if (netIF == null)
  86.         return new String[] { InetAddress.getLocalHost()
  87.                               .getHostAddress() };
  88.       else {
  89.         Vector<String> ips = new Vector<String>();
  90.         Enumeration e = netIF.getInetAddresses();
  91.         while (e.hasMoreElements())
  92.           ips.add(((InetAddress) e.nextElement()).getHostAddress());
  93.         return ips.toArray(new String[] {});
  94.       }
  95.     } catch (SocketException e) {
  96.       return new String[] { InetAddress.getLocalHost().getHostAddress() };
  97.     }
  98.   }
  99.   /**
  100.    * Returns the first available IP address associated with the provided
  101.    * network interface
  102.    * 
  103.    * @param strInterface
  104.    *            The name of the network interface to query (e.g. eth0)
  105.    * @return The IP address in text form
  106.    * @throws UnknownHostException
  107.    *             If one is encountered in querying the default interface
  108.    */
  109.   public static String getDefaultIP(String strInterface)
  110.     throws UnknownHostException {
  111.     String[] ips = getIPs(strInterface);
  112.     return ips[0];
  113.   }
  114.   /**
  115.    * Returns all the host names associated by the provided nameserver with the
  116.    * address bound to the specified network interface
  117.    * 
  118.    * @param strInterface
  119.    *            The name of the network interface to query (e.g. eth0)
  120.    * @param nameserver
  121.    *            The DNS host name
  122.    * @return A string vector of all host names associated with the IPs tied to
  123.    *         the specified interface
  124.    * @throws UnknownHostException
  125.    */
  126.   public static String[] getHosts(String strInterface, String nameserver)
  127.     throws UnknownHostException {
  128.     String[] ips = getIPs(strInterface);
  129.     Vector<String> hosts = new Vector<String>();
  130.     for (int ctr = 0; ctr < ips.length; ctr++)
  131.       try {
  132.         hosts.add(reverseDns(InetAddress.getByName(ips[ctr]),
  133.                              nameserver));
  134.       } catch (Exception e) {
  135.       }
  136.     if (hosts.size() == 0)
  137.       return new String[] { InetAddress.getLocalHost().getCanonicalHostName() };
  138.     else
  139.       return hosts.toArray(new String[] {});
  140.   }
  141.   /**
  142.    * Returns all the host names associated by the default nameserver with the
  143.    * address bound to the specified network interface
  144.    * 
  145.    * @param strInterface
  146.    *            The name of the network interface to query (e.g. eth0)
  147.    * @return The list of host names associated with IPs bound to the network
  148.    *         interface
  149.    * @throws UnknownHostException
  150.    *             If one is encountered while querying the deault interface
  151.    * 
  152.    */
  153.   public static String[] getHosts(String strInterface)
  154.     throws UnknownHostException {
  155.     return getHosts(strInterface, null);
  156.   }
  157.   /**
  158.    * Returns the default (first) host name associated by the provided
  159.    * nameserver with the address bound to the specified network interface
  160.    * 
  161.    * @param strInterface
  162.    *            The name of the network interface to query (e.g. eth0)
  163.    * @param nameserver
  164.    *            The DNS host name
  165.    * @return The default host names associated with IPs bound to the network
  166.    *         interface
  167.    * @throws UnknownHostException
  168.    *             If one is encountered while querying the deault interface
  169.    */
  170.   public static String getDefaultHost(String strInterface, String nameserver)
  171.     throws UnknownHostException {
  172.     if (strInterface.equals("default")) 
  173.       return InetAddress.getLocalHost().getCanonicalHostName();
  174.     if (nameserver != null && nameserver.equals("default"))
  175.       return getDefaultHost(strInterface);
  176.     String[] hosts = getHosts(strInterface, nameserver);
  177.     return hosts[0];
  178.   }
  179.   /**
  180.    * Returns the default (first) host name associated by the default
  181.    * nameserver with the address bound to the specified network interface
  182.    * 
  183.    * @param strInterface
  184.    *            The name of the network interface to query (e.g. eth0)
  185.    * @return The default host name associated with IPs bound to the network
  186.    *         interface
  187.    * @throws UnknownHostException
  188.    *             If one is encountered while querying the deault interface
  189.    */
  190.   public static String getDefaultHost(String strInterface)
  191.     throws UnknownHostException {
  192.     return getDefaultHost(strInterface, null);
  193.   }
  194. }