private static InetAddress[] getAllByName0(String host, InetAddress reqAddr, boolean check)
throws UnknownHostException {
/* If it gets here it is presumed to be a hostname */
/* Cache.get can return: null, unknownAddress, or InetAddress[] */
Object obj = null;
Object objcopy = null;
/* make sure the connection to the host is allowed, before we
* give out a hostname
*/
if (check) {
SecurityManager security = System.getSecurityManager();
if (security != null) {
security.checkConnect(host, -1);
}
}
obj = getCachedAddress(host);
/* If no entry in cache, then do the host lookup */
if (obj == null) {
obj = getAddressFromNameService(host, reqAddr);
}
if (obj == unknown_array) throw new UnknownHostException(host);
/* Make a copy of the InetAddress array */
objcopy = ((InetAddress[]) obj).clone();
return (InetAddress[]) objcopy;
}
static HttpClient New(
SSLSocketFactory sf,
URL url,
HostnameVerifier hv,
String proxy,
int proxyPort,
boolean useCache)
throws IOException {
HttpsClient ret = null;
if (useCache) {
/* see if one's already around */
ret = (HttpsClient) kac.get(url, sf);
if (ret != null) {
ret.cachedHttpClient = true;
}
}
if (ret == null) {
ret = new HttpsClient(sf, url, proxy, proxyPort);
} else {
SecurityManager security = System.getSecurityManager();
if (security != null) {
security.checkConnect(url.getHost(), url.getPort());
}
ret.url = url;
}
ret.setHostnameVerifier(hv);
return ret;
}
/**
* Add an entry to the cache. If there's already an entry then for this host then the entry will
* be replaced.
*/
public Cache put(String host, Object address) {
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 expired = new LinkedList();
Iterator i = cache.keySet().iterator();
long now = System.currentTimeMillis();
while (i.hasNext()) {
String key = (String) i.next();
CacheEntry entry = (CacheEntry) cache.get(key);
if (entry.expiration >= 0 && entry.expiration < now) {
expired.add(key);
} else {
break;
}
}
i = expired.iterator();
while (i.hasNext()) {
cache.remove(i.next());
}
}
// 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(address, expiration);
cache.put(host, entry);
return this;
}
/**
* Returns the address of the local host. This is achieved by retrieving the name of the host from
* the system, then resolving that name into an <code>InetAddress</code>.
*
* <p>Note: The resolved address may be cached for a short period of time.
*
* <p>If there is a security manager, its <code>checkConnect</code> method is called with the
* local host name and <code>-1</code> as its arguments to see if the operation is allowed. If the
* operation is not allowed, an InetAddress representing the loopback address is returned.
*
* @return the address of the local host.
* @exception UnknownHostException if the local host name could not be resolved into an address.
* @see SecurityManager#checkConnect
* @see java.net.InetAddress#getByName(java.lang.String)
*/
public static InetAddress getLocalHost() throws UnknownHostException {
SecurityManager security = System.getSecurityManager();
try {
String local = impl.getLocalHostName();
if (security != null) {
security.checkConnect(local, -1);
}
if (local.equals("localhost")) {
return impl.loopbackAddress();
}
InetAddress ret = null;
synchronized (cacheLock) {
long now = System.currentTimeMillis();
if (cachedLocalHost != null) {
if ((now - cacheTime) < maxCacheTime) // Less than 5s old?
ret = cachedLocalHost;
else cachedLocalHost = null;
}
// we are calling getAddressFromNameService directly
// to avoid getting localHost from cache
if (ret == null) {
InetAddress[] localAddrs;
try {
localAddrs = (InetAddress[]) InetAddress.getAddressFromNameService(local, null);
} catch (UnknownHostException uhe) {
throw new UnknownHostException(local + ": " + uhe.getMessage());
}
cachedLocalHost = localAddrs[0];
cacheTime = now;
ret = localAddrs[0];
}
}
return ret;
} catch (java.lang.SecurityException e) {
return impl.loopbackAddress();
}
}
/**
* Returns the hostname for this address.
*
* <p>If there is a security manager, this method first calls its <code>checkConnect</code> method
* with the hostname and <code>-1</code> as its arguments to see if the calling code is allowed to
* know the hostname for this IP address, i.e., to connect to the host. If the operation is not
* allowed, it will return the textual representation of the IP address.
*
* @return the host name for this IP address, or if the operation is not allowed by the security
* check, the textual representation of the IP address.
* @param check make security check if true
* @see SecurityManager#checkConnect
*/
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
* the hostname for this IP address, ie, connect to the host
*/
if (check) {
SecurityManager sec = System.getSecurityManager();
if (sec != null) {
sec.checkConnect(host, -1);
}
}
/* now get all the IP addresses for this hostname,
* and make sure one of them matches the original IP
* address. We do this to try and prevent spoofing.
*/
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;
}
/**
* Query the cache for the specific host. If found then return its CacheEntry, or null if not
* found.
*/
public CacheEntry get(String host) {
int policy = getPolicy();
if (policy == InetAddressCachePolicy.NEVER) {
return null;
}
CacheEntry entry = (CacheEntry) 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;
}