+2000-11-02 Warren Levy <warrenl@cygnus.com>
+
+ * java/net/InetAddress.java (addr): Renamed from 'address'.
+ (address): New field to match Serialized Form doc.
+ (hostName): Renamed from 'hostname' to match Serialized Form doc.
+ (family): New serialization field.
+ (serialVersionUID): New field.
+ (readObject): New method.
+ (writeObject): New method.
+ (getFamily): New native method.
+ (InetAddress): Set family.
+ * java/net/natInetAddress.cc (getFamily): New method.
+ (addr): Renamed from 'address'.
+ (hostName): Renamed from 'hostname' to match Serialized Form doc.
+ * java/net/natPlainDatagramSocketImpl.cc (addr): Renamed from 'address'.
+ * java/net/natPlainSocketImpl.cc (addr): Renamed from 'address'.
+
2000-11-03 Bryce McKinlay <bryce@albatross.co.nz>
* java/util/AbstractList.java (SubList): Make it a top-level private
// INetAddress.java -- An Internet Protocol (IP) address.
-/* Copyright (C) 1998, 1999 Free Software Foundation
+/* Copyright (C) 1998, 1999, 2000 Free Software Foundation
This file is part of libgcj.
details. */
package java.net;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.io.IOException;
/**
* @author Per Bothner
public final class InetAddress implements java.io.Serializable
{
- byte[] address;
- String hostname;
+ // The Serialized Form specifies that an int 'address' is saved/restored.
+ // This class uses a byte array internally so we'll just do the conversion
+ // at serialization time and leave the rest of the algorithm as is.
+ private int address;
+ transient byte[] addr;
+ String hostName;
+ // The field 'family' seems to be the AF_ value.
+ // FIXME: Much of the code in the other java.net classes does not make
+ // use of this family field. A better implementation would be to make
+ // use of getaddrinfo() and have other methods just check the family
+ // field rather than examining the length of the address each time.
+ int family;
+ private static final long serialVersionUID = 3286316764910316507L;
+
+ private void readObject(ObjectInputStream ois)
+ throws IOException, ClassNotFoundException
+ {
+ ois.defaultReadObject();
+ addr = new byte[4];
+ addr[3] = (byte) address;
+ for (int i = 2; i >= 0; --i)
+ addr[i] = (byte) (address >>= 8);
+ // Ignore family from serialized data. Since the saved address is 32 bits
+ // the deserialized object will have an IPv4 address i.e. AF_INET family.
+ // FIXME: An alternative is to call the aton method on the deserialized
+ // hostname to get a new address. The Serialized Form doc is silent
+ // on how these fields are used.
+ family = getFamily (addr);
+ }
+
+ private void writeObject(ObjectOutputStream oos) throws IOException
+ {
+ // Build a 32 bit address from the last 4 bytes of a 4 byte IPv4 address
+ // or a 16 byte IPv6 address.
+ int len = addr.length;
+ int i = len - 4;
+ for (; i < len; i++)
+ address = address << 8 | (((int) addr[i]) & 0xFF);
+ oos.defaultWriteObject();
+ }
+
+ private static native int getFamily (byte[] address);
InetAddress (byte[] address, String hostname)
{
- this.address = address;
- this.hostname = hostname;
+ addr = address;
+ hostName = hostname;
+ if (address != null)
+ family = getFamily (address);
}
public boolean isMulticastAddress ()
{
- int len = address.length;
+ int len = addr.length;
if (len == 4)
- return (address[0] & 0xF0) == 0xE0;
+ return (addr[0] & 0xF0) == 0xE0;
if (len == 16)
- return address[0] == (byte) 0xFF;
+ return addr[0] == (byte) 0xFF;
return false;
}
public String getHostName ()
{
- if (hostname == null)
+ if (hostName == null)
lookup (null, this, false);
- return hostname;
+ 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();
+ return (byte[]) addr.clone();
}
/* Helper function due to a CNI limitation. */
public String getHostAddress ()
{
StringBuffer sbuf = new StringBuffer(40);
- int len = address.length;
+ int len = addr.length;
int i = 0;
if (len == 16)
{ // An IPv6 address.
{
if (i >= 16)
return sbuf.toString();
- int x = ((address[i] & 0xFF) << 8) | (address[i+1] & 0xFF);
+ int x = ((addr[i] & 0xFF) << 8) | (addr[i+1] & 0xFF);
boolean empty = sbuf.length() == 0;
if (empty)
{
}
for ( ; ; )
{
- sbuf.append(address[i] & 0xFF);
+ sbuf.append(addr[i] & 0xFF);
i++;
if (i == len)
break;
// 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 len = addr.length;
int i = len > 4 ? len - 4 : 0;
for ( ; i < len; i++)
- hash = (hash << 8) | (address[i] & 0xFF);
+ hash = (hash << 8) | (addr[i] & 0xFF);
return hash;
}
// 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;
+ byte[] addr1 = addr;
+ byte[] addr2 = ((InetAddress) obj).addr;
if (addr1.length != addr2.length)
return false;
for (int i = addr1.length; --i >= 0; )
// 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))
+ || (s != null && localhost.addr != localhostAddress))
getLocalHost(s);
return localhost;
}
return NULL;
}
+jint
+java::net::InetAddress::getFamily (jbyteArray bytes)
+{
+ return 0;
+}
+
JArray<java::net::InetAddress*> *
java::net::InetAddress::lookup (jstring, java::net::InetAddress *, jboolean)
{
return result;
}
+jint
+java::net::InetAddress::getFamily (jbyteArray bytes)
+{
+ int len = bytes->length;
+ if (len == 4)
+ return AF_INET;
+#ifdef HAVE_INET6
+ else if (len == 16)
+ return AF_INET6;
+#endif /* HAVE_INET6 */
+ else
+ JvFail ("unrecognized size");
+}
+
JArray<java::net::InetAddress*> *
java::net::InetAddress::lookup (jstring host, java::net::InetAddress* iaddr,
}
else
{
- jbyteArray bytes = iaddr->address;
+ jbyteArray bytes = iaddr->addr;
char *chars = (char*) elements (bytes);
int len = bytes->length;
int type;
if (len == 4)
{
val = chars;
- type = AF_INET;
+ type = iaddr->family = AF_INET;
}
#ifdef HAVE_INET6
else if (len == 16)
{
val = (char *) &chars;
- type = AF_INET6;
+ type = iaddr->family = AF_INET6;
}
#endif /* HAVE_INET6 */
else
java::lang::SecurityException *ex = checkConnect (host);
if (ex != NULL)
{
- if (iaddr == NULL || iaddr->address == NULL)
+ if (iaddr == NULL || iaddr->addr == NULL)
throw ex;
hptr = NULL;
}
}
if (hptr == NULL)
{
- if (iaddr != NULL && iaddr->address != NULL)
+ if (iaddr != NULL && iaddr->addr != NULL)
{
- iaddr->hostname = iaddr->getHostAddress();
+ iaddr->hostName = iaddr->getHostAddress();
return NULL;
}
else
{
if (iaddrs[i] == NULL)
iaddrs[i] = new java::net::InetAddress (NULL, NULL);
- if (iaddrs[i]->hostname == NULL)
- iaddrs[i]->hostname = host;
- if (iaddrs[i]->address == NULL)
+ if (iaddrs[i]->hostName == NULL)
+ iaddrs[i]->hostName = host;
+ if (iaddrs[i]->addr == NULL)
{
char *bytes = hptr->h_addr_list[i];
- iaddrs[i]->address = JvNewByteArray (hptr->h_length);
- memcpy (elements (iaddrs[i]->address), bytes, hptr->h_length);
+ iaddrs[i]->addr = JvNewByteArray (hptr->h_length);
+ iaddrs[i]->family = getFamily (iaddrs[i]->addr);
+ memcpy (elements (iaddrs[i]->addr), bytes, hptr->h_length);
}
}
return result;
union SockAddr u;
struct sockaddr *ptr = (struct sockaddr *) &u.address;
// FIXME: Use getaddrinfo() to get actual protocol instead of assuming ipv4.
- jbyteArray haddress = host->address;
+ jbyteArray haddress = host->addr;
jbyte *bytes = elements (haddress);
int len = haddress->length;
else
throw new java::net::SocketException (JvNewStringUTF ("invalid family"));
- i->address = raddr;
+ i->addr = raddr;
return rport;
error:
char* strerr = strerror (errno);
// FIXME: Deal with Multicast and if the socket is connected.
jint rport = p->getPort();
union SockAddr u;
- jbyteArray haddress = p->getAddress()->address;
+ jbyteArray haddress = p->getAddress()->addr;
jbyte *bytes = elements (haddress);
int len = haddress->length;
struct sockaddr *ptr = (struct sockaddr *) &u.address;
jboolean join)
{
union McastReq u;
- jbyteArray haddress = inetaddr->address;
+ jbyteArray haddress = inetaddr->addr;
jbyte *bytes = elements (haddress);
int len = haddress->length;
int level, opname;
int level, opname;
const char *ptr;
- haddress = ((java::net::InetAddress *) value)->address;
+ haddress = ((java::net::InetAddress *) value)->addr;
bytes = elements (haddress);
len = haddress->length;
if (len == 4)
OSDN Git Service
