Back to index...

	/*
	* Copyright (c) 1998, 2014, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation. Oracle designates this
	* particular file as subject to the "Classpath" exception as provided
	* by Oracle in the LICENSE file that accompanied this code.
	*
	* This code is distributed in the hope that it will be useful, but WITHOUT
	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*/

	package sun.net;

	import java.security.PrivilegedAction;
	import java.security.Security;

	public final class InetAddressCachePolicy {

	// Controls the cache policy for successful lookups only
	private static final String cachePolicyProp = "networkaddress.cache.ttl";
	private static final String cachePolicyPropFallback =
	"sun.net.inetaddr.ttl";

	// Controls the cache policy for negative lookups only
	private static final String negativeCachePolicyProp =
	"networkaddress.cache.negative.ttl";
	private static final String negativeCachePolicyPropFallback =
	"sun.net.inetaddr.negative.ttl";

	public static final int FOREVER = -1;
	public static final int NEVER = 0;

	/* default value for positive lookups */
	public static final int DEFAULT_POSITIVE = 30;

	/* The Java-level namelookup cache policy for successful lookups:
	*
	* -1: caching forever
	* any positive value: the number of seconds to cache an address for
	*
	* default value is forever (FOREVER), as we let the platform do the
	* caching. For security reasons, this caching is made forever when
	* a security manager is set.
	*/
	private static volatile int cachePolicy = FOREVER;

	/* The Java-level namelookup cache policy for negative lookups:
	*
	* -1: caching forever
	* any positive value: the number of seconds to cache an address for
	*
	* default value is 0. It can be set to some other value for
	* performance reasons.
	*/
	private static volatile int negativeCachePolicy = NEVER;

	/*
	* Whether or not the cache policy for successful lookups was set
	* using a property (cmd line).
	*/
	private static boolean propertySet;

	/*
	* Whether or not the cache policy for negative lookups was set
	* using a property (cmd line).
	*/
	private static boolean propertyNegativeSet;

	/*
	* Initialize
	*/
	static {

	Integer tmp = java.security.AccessController.doPrivileged(
	new PrivilegedAction<Integer>() {
	public Integer run() {
	try {
	String tmpString = Security.getProperty(cachePolicyProp);
	if (tmpString != null) {
	return Integer.valueOf(tmpString);
	}
	} catch (NumberFormatException ignored) {
	// Ignore
	}

	try {
	String tmpString = System.getProperty(cachePolicyPropFallback);
	if (tmpString != null) {
	return Integer.decode(tmpString);
	}
	} catch (NumberFormatException ignored) {
	// Ignore
	}
	return null;
	}
	});

	if (tmp != null) {
	cachePolicy = tmp < 0 ? FOREVER : tmp;
	propertySet = true;
	} else {
	/* No properties defined for positive caching. If there is no
	* security manager then use the default positive cache value.
	*/
	if (System.getSecurityManager() == null) {
	cachePolicy = DEFAULT_POSITIVE;
	}
	}
	tmp = java.security.AccessController.doPrivileged (
	new PrivilegedAction<Integer>() {
	public Integer run() {
	try {
	String tmpString = Security.getProperty(negativeCachePolicyProp);
	if (tmpString != null) {
	return Integer.valueOf(tmpString);
	}
	} catch (NumberFormatException ignored) {
	// Ignore
	}

	try {
	String tmpString = System.getProperty(negativeCachePolicyPropFallback);
	if (tmpString != null) {
	return Integer.decode(tmpString);
	}
	} catch (NumberFormatException ignored) {
	// Ignore
	}
	return null;
	}
	});

	if (tmp != null) {
	negativeCachePolicy = tmp < 0 ? FOREVER : tmp;
	propertyNegativeSet = true;
	}
	}

	public static int get() {
	return cachePolicy;
	}

	public static int getNegative() {
	return negativeCachePolicy;
	}

	/**
	* Sets the cache policy for successful lookups if the user has not
	* already specified a cache policy for it using a
	* command-property.
	* @param newPolicy the value in seconds for how long the lookup
	* should be cached
	*/
	public static synchronized void setIfNotSet(int newPolicy) {
	/*
	* When setting the new value we may want to signal that the
	* cache should be flushed, though this doesn't seem strictly
	* necessary.
	*/
	if (!propertySet) {
	checkValue(newPolicy, cachePolicy);
	cachePolicy = newPolicy;
	}
	}

	/**
	* Sets the cache policy for negative lookups if the user has not
	* already specified a cache policy for it using a
	* command-property.
	* @param newPolicy the value in seconds for how long the lookup
	* should be cached
	*/
	public static void setNegativeIfNotSet(int newPolicy) {
	/*
	* When setting the new value we may want to signal that the
	* cache should be flushed, though this doesn't seem strictly
	* necessary.
	*/
	if (!propertyNegativeSet) {
	// Negative caching does not seem to have any security
	// implications.
	// checkValue(newPolicy, negativeCachePolicy);
	// but we should normalize negative policy
	negativeCachePolicy = newPolicy < 0 ? FOREVER : newPolicy;
	}
	}

	private static void checkValue(int newPolicy, int oldPolicy) {
	/*
	* If malicious code gets a hold of this method, prevent
	* setting the cache policy to something laxer or some
	* invalid negative value.
	*/
	if (newPolicy == FOREVER)
	return;

	if ((oldPolicy == FOREVER) \|\|
	(newPolicy < oldPolicy) \|\|
	(newPolicy < FOREVER)) {

	throw new
	SecurityException("can't make InetAddress cache more lax");
	}
	}
	}

Back to index...