home *** CD-ROM | disk | FTP | other *** search
/ S283 Planetary Science &n…he Search for Life DVD 2 / DVD-ROM.iso / install / jre1_3 / lib / rt.jar / java / net / InetAddress.class (.txt) < prev    next >
Encoding:
Java Class File  |  1979-12-31  |  6.5 KB  |  382 lines
  1. package java.net;
  2.  
  3. import java.io.Serializable;
  4. import java.security.AccessController;
  5. import java.util.HashMap;
  6. import sun.net.InetAddressCachePolicy;
  7. import sun.security.action.GetPropertyAction;
  8. import sun.security.action.LoadLibraryAction;
  9.  
  10. public final class InetAddress implements Serializable {
  11.    String hostName;
  12.    int address;
  13.    int family;
  14.    private static final long serialVersionUID = 3286316764910316507L;
  15.    private static HashMap addressCache;
  16.    private static InetAddress unknownAddress;
  17.    private static InetAddress localHost;
  18.    private static InetAddress[] unknown_array;
  19.    static InetAddress anyLocalAddress;
  20.    static InetAddressImpl impl;
  21.    private static HashMap lookupTable;
  22.    private static InetAddress loopbackHost;
  23.  
  24.    InetAddress() {
  25.       this.family = impl.getInetFamily();
  26.    }
  27.  
  28.    InetAddress(String var1, byte[] var2) {
  29.       this.hostName = var1;
  30.       this.family = impl.getInetFamily();
  31.       this.address = var2[3] & 255;
  32.       this.address |= var2[2] << 8 & '\uff00';
  33.       this.address |= var2[1] << 16 & 16711680;
  34.       this.address |= var2[0] << 24 & -16777216;
  35.    }
  36.  
  37.    public boolean isMulticastAddress() {
  38.       return (this.address & -268435456) == -536870912;
  39.    }
  40.  
  41.    public String getHostName() {
  42.       return this.getHostName(true);
  43.    }
  44.  
  45.    String getHostName(boolean var1) {
  46.       if (this.hostName == null) {
  47.          try {
  48.             this.hostName = impl.getHostByAddr(this.address);
  49.             if (var1) {
  50.                SecurityManager var2 = System.getSecurityManager();
  51.                if (var2 != null) {
  52.                   var2.checkConnect(this.hostName, -1);
  53.                }
  54.             }
  55.  
  56.             InetAddress[] var7 = getAllByName0(this.hostName, var1);
  57.             boolean var3 = false;
  58.             if (var7 != null) {
  59.                for(int var4 = 0; !var3 && var4 < var7.length; ++var4) {
  60.                   var3 = this.address == var7[var4].address;
  61.                }
  62.             }
  63.  
  64.             if (!var3) {
  65.                this.hostName = this.getHostAddress();
  66.                return this.getHostAddress();
  67.             }
  68.          } catch (SecurityException var5) {
  69.             this.hostName = this.getHostAddress();
  70.          } catch (UnknownHostException var6) {
  71.             this.hostName = this.getHostAddress();
  72.          }
  73.       }
  74.  
  75.       return this.hostName;
  76.    }
  77.  
  78.    public byte[] getAddress() {
  79.       byte[] var1 = new byte[]{(byte)(this.address >>> 24 & 255), (byte)(this.address >>> 16 & 255), (byte)(this.address >>> 8 & 255), (byte)(this.address & 255)};
  80.       return var1;
  81.    }
  82.  
  83.    public String getHostAddress() {
  84.       return (this.address >>> 24 & 255) + "." + (this.address >>> 16 & 255) + "." + (this.address >>> 8 & 255) + "." + (this.address >>> 0 & 255);
  85.    }
  86.  
  87.    public int hashCode() {
  88.       return this.address;
  89.    }
  90.  
  91.    public boolean equals(Object var1) {
  92.       return var1 != null && var1 instanceof InetAddress && ((InetAddress)var1).address == this.address;
  93.    }
  94.  
  95.    public String toString() {
  96.       return this.getHostName() + "/" + this.getHostAddress();
  97.    }
  98.  
  99.    private static void cacheAddress(String var0, Object var1) {
  100.       int var2 = InetAddressCachePolicy.get();
  101.       if (var2 != 0) {
  102.          long var3 = -1L;
  103.          if (var2 != -1) {
  104.             var3 = System.currentTimeMillis() + (long)(var2 * 1000);
  105.          }
  106.  
  107.          cacheAddress(var0, var1, var3);
  108.       }
  109.    }
  110.  
  111.    private static void cacheAddress(String var0, Object var1, long var2) {
  112.       var0 = var0.toLowerCase();
  113.       HashMap var4 = addressCache;
  114.       synchronized(var4) {
  115.          CacheEntry var5 = (CacheEntry)addressCache.get(var0);
  116.          if (var5 == null) {
  117.             var5 = new CacheEntry(var0, var1, var2);
  118.             addressCache.put(var0, var5);
  119.          } else {
  120.             var5.address = var1;
  121.             var5.expiration = var2;
  122.          }
  123.  
  124.       }
  125.    }
  126.  
  127.    private static Object getCachedAddress(String var0) {
  128.       var0 = var0.toLowerCase();
  129.       if (InetAddressCachePolicy.get() == 0) {
  130.          return null;
  131.       } else {
  132.          HashMap var1 = addressCache;
  133.          synchronized(var1) {
  134.             CacheEntry var2 = (CacheEntry)addressCache.get(var0);
  135.             if (var2 != null && var2.expiration < System.currentTimeMillis() && var2.expiration >= 0L) {
  136.                var2 = null;
  137.             }
  138.  
  139.             Object var3 = var2 != null ? var2.address : null;
  140.             return var3;
  141.          }
  142.       }
  143.    }
  144.  
  145.    public static InetAddress getByName(String var0) throws UnknownHostException {
  146.       Object var1 = null;
  147.       if (var0 != null && var0.length() != 0) {
  148.          if (!Character.isDigit(var0.charAt(0))) {
  149.             return getAllByName0(var0)[0];
  150.          } else {
  151.             int var2 = 0;
  152.             int var3 = 0;
  153.             char[] var4 = var0.toCharArray();
  154.             int var5 = 0;
  155.  
  156.             label54:
  157.             while(var5 < var4.length) {
  158.                char var6 = var4[var5];
  159.                if (var6 >= '0' && var6 <= '9') {
  160.                   int var7 = 0;
  161.  
  162.                   while(true) {
  163.                      if (var6 != '.') {
  164.                         if (var6 < '0' || var6 > '9') {
  165.                            return getAllByName0(var0)[0];
  166.                         }
  167.  
  168.                         var7 = var7 * 10 + var6 - 48;
  169.                         ++var5;
  170.                         if (var5 < var4.length) {
  171.                            var6 = var4[var5];
  172.                            continue;
  173.                         }
  174.                      }
  175.  
  176.                      if (var7 > 255) {
  177.                         return getAllByName0(var0)[0];
  178.                      }
  179.  
  180.                      var2 = (var2 << 8) + var7;
  181.                      ++var3;
  182.                      ++var5;
  183.                      continue label54;
  184.                   }
  185.                }
  186.  
  187.                return getAllByName0(var0)[0];
  188.             }
  189.  
  190.             if (var3 == 4 && !var0.endsWith(".")) {
  191.                InetAddress var8 = new InetAddress();
  192.                var8.address = var2;
  193.                var8.hostName = null;
  194.                return var8;
  195.             } else {
  196.                return getAllByName0(var0)[0];
  197.             }
  198.          }
  199.       } else {
  200.          return loopbackHost;
  201.       }
  202.    }
  203.  
  204.    public static InetAddress[] getAllByName(String var0) throws UnknownHostException {
  205.       if (var0 != null && var0.length() != 0) {
  206.          if (Character.isDigit(var0.charAt(0))) {
  207.             InetAddress[] var1 = new InetAddress[]{getByName(var0)};
  208.             return var1;
  209.          } else {
  210.             return getAllByName0(var0);
  211.          }
  212.       } else {
  213.          throw new UnknownHostException("empty string");
  214.       }
  215.    }
  216.  
  217.    private static InetAddress[] getAllByName0(String var0) throws UnknownHostException {
  218.       return getAllByName0(var0, true);
  219.    }
  220.  
  221.    static InetAddress[] getAllByName0(String var0, boolean var1) throws UnknownHostException {
  222.       Object var2 = null;
  223.       Object var3 = null;
  224.       if (var1) {
  225.          SecurityManager var4 = System.getSecurityManager();
  226.          if (var4 != null) {
  227.             var4.checkConnect(var0, -1);
  228.          }
  229.       }
  230.  
  231.       var2 = getCachedAddress(var0);
  232.       if (var2 == null) {
  233.          var2 = getAddressFromNameService(var0);
  234.       }
  235.  
  236.       if (var2 == unknown_array) {
  237.          throw new UnknownHostException(var0);
  238.       } else {
  239.          try {
  240.             var3 = ((InetAddress[])var2).clone();
  241.             if (var3 == null) {
  242.                throw new CloneNotSupportedException();
  243.             }
  244.          } catch (CloneNotSupportedException var5) {
  245.             ((Throwable)var5).printStackTrace();
  246.          }
  247.  
  248.          return (InetAddress[])var3;
  249.       }
  250.    }
  251.  
  252.    private static Object getAddressFromNameService(String var0) {
  253.       Object var1 = null;
  254.       if ((var1 = checkLookupTable(var0)) == null) {
  255.          try {
  256.             byte[][] var2 = impl.lookupAllHostAddr(var0);
  257.             InetAddress[] var3 = new InetAddress[var2.length];
  258.  
  259.             for(int var4 = 0; var4 < var2.length; ++var4) {
  260.                byte[] var5 = var2[var4];
  261.                var3[var4] = new InetAddress(var0, var5);
  262.             }
  263.  
  264.             var1 = var3;
  265.          } catch (UnknownHostException var10) {
  266.             var1 = unknown_array;
  267.          } finally {
  268.             cacheAddress(var0, var1);
  269.             updateLookupTable(var0);
  270.          }
  271.       }
  272.  
  273.       return var1;
  274.    }
  275.  
  276.    private static Object checkLookupTable(String var0) {
  277.       Object var1 = null;
  278.       HashMap var2 = lookupTable;
  279.       synchronized(var2) {
  280.          if (!lookupTable.containsKey(var0)) {
  281.             lookupTable.put(var0, (Object)null);
  282.             return var1;
  283.          }
  284.  
  285.          while(lookupTable.containsKey(var0)) {
  286.             try {
  287.                lookupTable.wait();
  288.             } catch (InterruptedException var7) {
  289.             }
  290.          }
  291.       }
  292.  
  293.       var1 = getCachedAddress(var0);
  294.       if (var1 == null) {
  295.          HashMap var3 = lookupTable;
  296.          synchronized(var3) {
  297.             lookupTable.put(var0, (Object)null);
  298.          }
  299.       }
  300.  
  301.       return var1;
  302.    }
  303.  
  304.    private static void updateLookupTable(String var0) {
  305.       HashMap var1 = lookupTable;
  306.       synchronized(var1) {
  307.          lookupTable.remove(var0);
  308.          lookupTable.notifyAll();
  309.       }
  310.    }
  311.  
  312.    public static synchronized InetAddress getLocalHost() throws UnknownHostException {
  313.       if (localHost.equals(unknownAddress)) {
  314.          throw new UnknownHostException();
  315.       } else {
  316.          SecurityManager var0 = System.getSecurityManager();
  317.  
  318.          try {
  319.             if (localHost.address == -1) {
  320.                localHost = getAllByName(localHost.hostName)[0];
  321.             }
  322.  
  323.             if (var0 != null) {
  324.                var0.checkConnect(localHost.getHostName(), -1);
  325.             }
  326.          } catch (SecurityException var2) {
  327.             return loopbackHost;
  328.          }
  329.  
  330.          return localHost;
  331.       }
  332.    }
  333.  
  334.    private static native void init();
  335.  
  336.    static {
  337.       AccessController.doPrivileged(new LoadLibraryAction("net"));
  338.       init();
  339.       addressCache = new HashMap();
  340.       lookupTable = new HashMap();
  341.       String var0 = (String)AccessController.doPrivileged(new GetPropertyAction("impl.prefix", ""));
  342.  
  343.       try {
  344.          impl = null;
  345.          impl = (InetAddressImpl)Class.forName("java.net." + var0 + "InetAddressImpl").newInstance();
  346.       } catch (ClassNotFoundException var6) {
  347.          System.err.println("Class not found: java.net." + var0 + "InetAddressImpl:\ncheck impl.prefix property " + "in your properties file.");
  348.       } catch (InstantiationException var7) {
  349.          System.err.println("Could not instantiate: java.net." + var0 + "InetAddressImpl:\ncheck impl.prefix property " + "in your properties file.");
  350.       } catch (IllegalAccessException var8) {
  351.          System.err.println("Cannot access class: java.net." + var0 + "InetAddressImpl:\ncheck impl.prefix property " + "in your properties file.");
  352.       }
  353.  
  354.       if (impl == null) {
  355.          try {
  356.             impl = (InetAddressImpl)Class.forName("java.net.InetAddressImpl").newInstance();
  357.          } catch (Exception var5) {
  358.             throw new Error("System property impl.prefix incorrect");
  359.          }
  360.       }
  361.  
  362.       unknownAddress = new InetAddress();
  363.       anyLocalAddress = new InetAddress();
  364.       impl.makeAnyLocalAddress(anyLocalAddress);
  365.       byte[] var1 = new byte[]{127, 0, 0, 1};
  366.       loopbackHost = new InetAddress("localhost", var1);
  367.  
  368.       try {
  369.          localHost = new InetAddress();
  370.          localHost.hostName = impl.getLocalHostName();
  371.          localHost.address = -1;
  372.       } catch (Exception var4) {
  373.          localHost = unknownAddress;
  374.       }
  375.  
  376.       String var2 = "0.0.0.0";
  377.       unknown_array = new InetAddress[1];
  378.       unknown_array[0] = new InetAddress(var2, unknownAddress.getAddress());
  379.       cacheAddress(var2, unknown_array, -1L);
  380.    }
  381. }
  382.