/**

static final int IPv4 = 1;

/**

static final int IPv6 = 2;

/* Specify address family preference */

static transient boolean preferIPv6Address = false;

static class InetAddressHolder {

InetAddressHolder() {}

InetAddressHolder(String hostName, int address, int family) {

this.hostName = hostName;

this.address = address;

this.family = family;

}

void init(String hostName, int family) {

this.hostName = hostName;

if (family != -1) {

this.family = family;

}

}

String hostName;

String getHostName() {

return hostName;

}

/**

int address;

int getAddress() {

return address;

}

/**

int family;

int getFamily() {

return family;

}

}

/* Used to store the serializable fields of InetAddress */

final transient InetAddressHolder holder;

InetAddressHolder holder() {

return holder;

}

/* Used to store the name service provider */

private static List<NameService> nameServices = null;

/* Used to store the best available hostname */

private transient String canonicalHostName = null;

/** use serialVersionUID from JDK 1.0.2 for interoperability */

private static final long serialVersionUID = 3286316764910316507L;

/*

static {

preferIPv6Address = java.security.AccessController.doPrivileged(

new GetBooleanAction("java.net.preferIPv6Addresses")).booleanValue();

AccessController.doPrivileged(

new java.security.PrivilegedAction<Void>() {

public Void run() {

System.loadLibrary("net");

return null;

}

});

init();

}

/**

InetAddress() {

holder = new InetAddressHolder();

}

/**

private Object readResolve() throws ObjectStreamException {

// will replace the deserialized 'this' object

return new Inet4Address(holder().getHostName(), holder().getAddress());

}

/**

public boolean isMulticastAddress() {

return false;

}

/**

public boolean isAnyLocalAddress() {

return false;

}

/**

public boolean isLoopbackAddress() {

return false;

}

/**

public boolean isLinkLocalAddress() {

return false;

}

/**

public boolean isSiteLocalAddress() {

return false;

}

/**

public boolean isMCGlobal() {

return false;

}

/**

public boolean isMCNodeLocal() {

return false;

}

/**

public boolean isMCLinkLocal() {

return false;

}

/**

public boolean isMCSiteLocal() {

return false;

}

/**

public boolean isMCOrgLocal() {

return false;

}

/**

public boolean isReachable(int timeout) throws IOException {

return isReachable(null, 0 , timeout);

}

/**

public boolean isReachable(NetworkInterface netif, int ttl,

int timeout) throws IOException {

if (ttl < 0)

throw new IllegalArgumentException("ttl can't be negative");

if (timeout < 0)

throw new IllegalArgumentException("timeout can't be negative");

return impl.isReachable(this, timeout, netif, ttl);

}

/**

public String getHostName() {

return getHostName(true);

}

/**

String getHostName(boolean check) {

if (holder().getHostName() == null) {

holder().hostName = InetAddress.getHostFromNameService(this, check);

}

return holder().getHostName();

}

/**

public String getCanonicalHostName() {

if (canonicalHostName == null) {

canonicalHostName =

InetAddress.getHostFromNameService(this, true);

}

return canonicalHostName;

}

/**

private static String getHostFromNameService(InetAddress addr, boolean check) {

String host = null;

for (NameService nameService : nameServices) {

try {

// first lookup the hostname

host = nameService.getHostByAddr(addr.getAddress());

/* check to see if calling code is allowed to know

if (check) {

SecurityManager sec = System.getSecurityManager();

if (sec != null) {

sec.checkConnect(host, -1);

}

}

/* now get all the IP addresses for this hostname,

InetAddress[] arr = InetAddress.getAllByName0(host, check);

boolean ok = false;

if(arr != null) {

for(int i = 0; !ok && i < arr.length; i++) {

ok = addr.equals(arr[i]);

}

}

//XXX: if it looks a spoof just return the address?

if (!ok) {

host = addr.getHostAddress();

return host;

}

break;

} catch (SecurityException e) {

host = addr.getHostAddress();

break;

} catch (UnknownHostException e) {

host = addr.getHostAddress();

// let next provider resolve the hostname

}

}

return host;

}

/**

public byte[] getAddress() {

return null;

}

/**

public String getHostAddress() {

return null;

}

/**

public int hashCode() {

return -1;

}

/**

public boolean equals(Object obj) {

return false;

}

/**

public String toString() {

String hostName = holder().getHostName();

return ((hostName != null) ? hostName : "")

+ "/" + getHostAddress();

}

/*

private static Cache addressCache = new Cache(Cache.Type.Positive);

private static Cache negativeCache = new Cache(Cache.Type.Negative);

private static boolean addressCacheInit = false;

static InetAddress[] unknown_array; // put THIS in cache

static InetAddressImpl impl;

private static final HashMap<String, Void> lookupTable = new HashMap<>();

/**

static final class CacheEntry {

CacheEntry(InetAddress[] addresses, long expiration) {

this.addresses = addresses;

this.expiration = expiration;

}

InetAddress[] addresses;

long expiration;

}

/**

static final class Cache {

private LinkedHashMap<String, CacheEntry> cache;

private Type type;

enum Type {Positive, Negative};

/**

public Cache(Type type) {

this.type = type;

cache = new LinkedHashMap<String, CacheEntry>();

}

private int getPolicy() {

if (type == Type.Positive) {

return InetAddressCachePolicy.get();

} else {

return InetAddressCachePolicy.getNegative();

}

}

/**

public Cache put(String host, InetAddress[] addresses) {

int policy = getPolicy();

if (policy == InetAddressCachePolicy.NEVER) {

return this;

}

// purge any expired entries

if (policy != InetAddressCachePolicy.FOREVER) {

// As we iterate in insertion order we can

// terminate when a non-expired entry is found.

LinkedList<String> expired = new LinkedList<>();

long now = System.currentTimeMillis();

for (String key : cache.keySet()) {

CacheEntry entry = cache.get(key);

if (entry.expiration >= 0 && entry.expiration < now) {

expired.add(key);

} else {

break;

}

}

for (String key : expired) {

cache.remove(key);

}

}

// create new entry and add it to the cache

// -- as a HashMap replaces existing entries we

// don't need to explicitly check if there is

// already an entry for this host.

long expiration;

if (policy == InetAddressCachePolicy.FOREVER) {

expiration = -1;

} else {

expiration = System.currentTimeMillis() + (policy * 1000);

}

CacheEntry entry = new CacheEntry(addresses, expiration);

cache.put(host, entry);

return this;

}

/**

public CacheEntry get(String host) {

int policy = getPolicy();

if (policy == InetAddressCachePolicy.NEVER) {

return null;

}

CacheEntry entry = cache.get(host);

// check if entry has expired

if (entry != null && policy != InetAddressCachePolicy.FOREVER) {

if (entry.expiration >= 0 &&

entry.expiration < System.currentTimeMillis()) {

cache.remove(host);

entry = null;

}

}

return entry;

}

}

/*

private static void cacheInitIfNeeded() {

assert Thread.holdsLock(addressCache);

if (addressCacheInit) {

return;

}

unknown_array = new InetAddress[1];

unknown_array[0] = impl.anyLocalAddress();

addressCache.put(impl.anyLocalAddress().getHostName(),

unknown_array);

addressCacheInit = true;

}

/*

private static void cacheAddresses(String hostname,

InetAddress[] addresses,

boolean success) {

hostname = hostname.toLowerCase();

synchronized (addressCache) {

cacheInitIfNeeded();

if (success) {

addressCache.put(hostname, addresses);

} else {

negativeCache.put(hostname, addresses);

}

}

}

/*

private static InetAddress[] getCachedAddresses(String hostname) {

hostname = hostname.toLowerCase();

// search both positive & negative caches

synchronized (addressCache) {

cacheInitIfNeeded();

CacheEntry entry = addressCache.get(hostname);

if (entry == null) {

entry = negativeCache.get(hostname);

}

if (entry != null) {

return entry.addresses;

}

}

// not found

return null;

}

private static NameService createNSProvider(String provider) {

if (provider == null)

return null;

NameService nameService = null;

if (provider.equals("default")) {

// initialize the default name service

nameService = new NameService() {

public InetAddress[] lookupAllHostAddr(String host)

throws UnknownHostException {

return impl.lookupAllHostAddr(host);

}

public String getHostByAddr(byte[] addr)

throws UnknownHostException {

return impl.getHostByAddr(addr);

}

};

} else {

final String providerName = provider;

try {

nameService = java.security.AccessController.doPrivileged(

new java.security.PrivilegedExceptionAction<NameService>() {

public NameService run() {

Iterator<NameServiceDescriptor> itr =

ServiceLoader.load(NameServiceDescriptor.class)

.iterator();

while (itr.hasNext()) {

NameServiceDescriptor nsd = itr.next();

if (providerName.

equalsIgnoreCase(nsd.getType()+","

+nsd.getProviderName())) {

try {

return nsd.createNameService();

} catch (Exception e) {

e.printStackTrace();

System.err.println(

"Cannot create name service:"

+providerName+": " + e);

}

}

}

return null;

}

}

);

} catch (java.security.PrivilegedActionException e) {

}

}

return nameService;

}

static {

// create the impl

impl = InetAddressImplFactory.create();

// get name service if provided and requested

String provider = null;;

String propPrefix = "sun.net.spi.nameservice.provider.";

int n = 1;

nameServices = new ArrayList<NameService>();

provider = AccessController.doPrivileged(

new GetPropertyAction(propPrefix + n));

while (provider != null) {

NameService ns = createNSProvider(provider);

if (ns != null)

nameServices.add(ns);

n++;

provider = AccessController.doPrivileged(

new GetPropertyAction(propPrefix + n));

}

// if not designate any name services provider,

// create a default one

if (nameServices.size() == 0) {

NameService ns = createNSProvider("default");

nameServices.add(ns);

}

}

/**