Initial revision

From-SVN: r26263

libjava/java/net/InetAddress.java

@@ -0,0 +1,255 @@
+// INetAddress.java -- An Internet Protocol (IP) address.
+
+/* Copyright (C) 1998, 1999  Cygnus Solutions
+
+   This file is part of libgcj.
+
+This software is copyrighted work licensed under the terms of the
+Libgcj License.  Please consult the file "LIBGCJ_LICENSE" for
+details.  */
+
+package java.net;
+
+/**
+ * @author Per Bothner
+ * @date January 6, 1999.
+ */
+
+/*
+ * Written using on-line Java Platform 1.2 API Specification, as well
+ * as "The Java Class Libraries", 2nd edition (Addison-Wesley, 1998).
+ * (The latter turns out to have some errors ...)
+ * Status:  Believed complete and correct.
+ */
+
+public final class InetAddress
+{
+  String hostname;
+  byte[] address;
+
+  InetAddress (byte[] address, String hostname)
+  {
+    this.address = address;
+    this.hostname = hostname;
+  }
+
+  public boolean isMulticastAddress ()
+  {
+    int len = address.length;
+    if (len == 4)
+      return (address[0] & 0xF0) == 0xE0;
+    if (len == 16)
+      return address[0] == (byte) 0xFF;
+    return false;
+  }
+
+  public String getHostName ()
+  {
+    if (hostname == null)
+      lookup (null, this, false);
+    return hostname;
+  }
+
+  public byte[] getAddress ()
+  {
+    // An experiment shows that JDK1.2 returns a different byte array each
+    // time.  This makes sense, in terms of security.
+    return (byte[]) address.clone();
+  }
+
+  /* Helper function due to a CNI limitation.  */
+  private static InetAddress[] allocArray (int count)
+  {
+    return new InetAddress[count];
+  }
+
+  /* Helper function due to a CNI limitation.  */
+  private static SecurityException checkConnect (String hostname)
+  {
+    SecurityManager s = System.getSecurityManager();
+    if (s == null)
+      return null;
+    try
+      {
+	s.checkConnect(hostname, -1);
+	return null;
+      }
+    catch (SecurityException ex)
+      {
+	return ex;
+      }
+  }
+
+  public String getHostAddress ()
+  {
+    StringBuffer sbuf = new StringBuffer(40);
+    int len = address.length;
+    int i = 0;
+    if (len == 16)
+      { // An IPv6 address.
+	for (;  ;  i += 2)
+	  {
+	    if (i >= 16)
+	      return sbuf.toString();
+	    int x = ((address[i] & 0xFF) << 8) | (address[i+1] & 0xFF);
+	    boolean empty = sbuf.length() == 0;
+	    if (empty)
+	      {
+		if (i == 10 && x == 0xFFFF)
+		  { // IPv4-mapped IPv6 address.
+		    sbuf.append(":FFFF:");
+		    break;  // Continue as IPv4 address;
+		  }
+		else if (i == 12)
+		  { // IPv4-compatible IPv6 address.
+		    sbuf.append(':');
+		    break;  // Continue as IPv4 address.
+		  }
+		else if (i > 0)
+		  sbuf.append("::");
+	      }
+	    else
+	      sbuf.append(':');
+	    if (x != 0 || i >= 14)
+	      sbuf.append(Integer.toHexString(x).toUpperCase());
+	  }
+      }
+    for ( ;  ; )
+      {
+	sbuf.append(address[i] & 0xFF);
+	i++;
+	if (i == len)
+	  break;
+	sbuf.append('.');
+      }
+    return sbuf.toString();
+  }
+
+  public int hashCode()
+  {
+    // There hashing algorithm is not specified, but a simple experiment
+    // shows that it is equal to the address, as a 32-bit big-endian integer.
+    int hash = 0;
+    int len = address.length;
+    int i = len > 4 ? len - 4 : 0;
+    for ( ; i < len;  i++)
+      hash = (hash << 8) | (address[i] & 0xFF);
+    return hash;
+  }
+
+  public boolean equals (Object obj)
+  {
+    if (obj == null || ! (obj instanceof InetAddress))
+      return false;
+    // "The Java Class Libraries" 2nd edition says "If a machine has
+    // multiple names instances of InetAddress for different name of
+    // that same machine are not equal.  This is because they have
+    // different host names."  This violates the description in the
+    // JDK 1.2 API documentation.  A little experiementation
+    // shows that the latter is correct.
+    byte[] addr1 = address;
+    byte[] addr2 = ((InetAddress) obj).address;
+    if (addr1.length != addr2.length)
+      return false;
+    for (int i = addr1.length;  --i >= 0;  )
+      if (addr1[i] != addr2[i])
+	return false;
+    return true;
+  }
+
+  public String toString()
+  {
+    return getHostName()+'/'+getHostAddress();
+  }
+
+  /** If host is a valid numeric IP address, return the numeric address.
+   * Otherwise, return null. */
+  private static native byte[] aton (String host);
+
+  private static native InetAddress[] lookup
+  (String hostname, InetAddress addr, boolean all);
+
+  public static InetAddress getByName (String host)
+    throws UnknownHostException
+  {
+    if (host == null)
+      return getLocalHost();
+    byte[] address = aton(host);
+    if (address != null)
+      return new InetAddress(address, null);
+    InetAddress iaddr = new InetAddress(null, null);
+    lookup(host, iaddr, false);
+    return iaddr;
+  }
+
+  public static InetAddress[] getAllByName (String host)
+    throws UnknownHostException
+  {
+    byte[] address = aton(host);
+    if (address != null)
+      {
+	InetAddress[] result = new InetAddress[1];
+	result[0] = new InetAddress(address, null);
+	return result;
+      }
+    return lookup(host, null, true);
+  }
+
+  private static final byte[] localhostAddress = { 127, 0, 0, 1 };
+
+  private static native String getLocalHostname ();
+
+  private static InetAddress localhost = null;
+
+  public static InetAddress getLocalHost() throws UnknownHostException
+  {
+    SecurityManager s = System.getSecurityManager();
+    // Experimentation shows that JDK1.2 does cache the result.
+    // However, if there is a security manager, and the cached result
+    // is other than "localhost", we need to check again.
+    if (localhost == null
+	|| (s != null && localhost.address != localhostAddress))
+      getLocalHost(s);
+    return localhost;
+  }
+
+  private static synchronized void getLocalHost(SecurityManager s)
+    throws UnknownHostException
+  {
+    // Check the localhost cache again, now that we've synchronized.
+    if (s == null && localhost != null)
+      return;
+    String hostname = getLocalHostname();
+    if (s != null)
+      {
+	// "The Java Class Libraries" suggests that if the security
+	// manager disallows getting the local host name, then
+	// we use the loopback host.
+	// However, the JDK 1.2 API claims to throw SecurityException,
+	// which seems to suggest SecurityException is *not* caught.
+	// In this case, experimentation shows that former is correct.
+	try
+	  {
+	    // This is wrong, if the name returned from getLocalHostname()
+	    // is not a fully qualified name.  FIXME.
+	    s.checkConnect(hostname, -1);
+	  }
+	catch (SecurityException ex)
+	  {
+	    hostname = null;
+	  }
+      }
+    if (hostname != null)
+      {
+	try
+	  {
+	    localhost = getByName(hostname);
+	  }
+	catch (Exception ex)
+	  {
+	  }
+      }
+    if (localhost == null)
+      localhost = new InetAddress (localhostAddress, "localhost");
+  }
+}