/*
 * 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");
 }
 }
}