/*

 * CDDL HEADER START

 *

 * The contents of this file are subject to the terms of the

 *

 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE

 * or http://www.opensolaris.org/os/licensing.

 * See the License for the specific language governing permissions

 * and limitations under the License.

 *

 * When distributing Covered Code, include this CDDL HEADER in each

 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.

 * If applicable, add the following below this CDDL HEADER, with the

 * fields enclosed by brackets "[]" replaced with your own identifying

 * information: Portions Copyright [yyyy] [name of copyright owner]

 *

 * CDDL HEADER END

 */

/*

 * Copyright 1999-2003 Sun Microsystems, Inc.  All rights reserved.

 * Use is subject to license terms.

 *

 */

//  SLPConfig.java

//

/**

 * This class is a singleton - it has the configuration which

 * is the default.  It reads from a configuration file and

 * this overrides the default.  If the config file does not

 * expressly forbid it, the ServiceLocationManager interface

 * allows some of these configuration options to be modified.

 * This configuration is refered to by many points of the

 * implementation. Note that the class itself is abstract,

 * and is extended by two classes, one that allows slpd to

 * run as an SA server only, the other allows it to run

 * as a DA as well.

 *

 * @see com.sun.slp.ServiceLocationManager

 */

package com.sun.slp;

import java.net.*;

import java.util.*;

import java.text.*;

import java.io.*;

/*

 * This class contains all configuration information.  It

 * is hard coded to know the defaults, and will read a config

 * file if it is present.  The config file will override the

 * default values and policy.  If the config file allows it

 * the user may reset some of these values using the

 * ServiceLocationManager interface.

 *

 */

class SLPConfig {

    /**

     * A Java properties file defines `\' as an escape character, which

     * conflicts with the SLP API escape convention. Therefore, we need

     * to subclass properties so we can parse in the file ourselves.

     */

    public static class SLPProperties extends Properties {

	SLPProperties(Properties p) {

	    super(p);

	}

	// Parse the SLP properties file ourselves. Groan! We don't recognize

	//  backslash as an escape.

	public synchronized void load(InputStream in) throws IOException {

	    BufferedReader rd = new BufferedReader(new InputStreamReader(in));

	    while (rd.ready()) {

		String ln = rd.readLine();

		// Throw out anything that begins with '#' or ';'.

		if (ln.startsWith("#") ||

		    ln.startsWith(";") ||

		    ln.length() <= 0) {

		    continue;

		}

		// Parse out equals sign, if any. Note that we trim any

		//  white space preceding or following data strings.   

		//  Although the grammar doesn't allow it, users may 

		//  enter blanks in their configuration files.

		// NOTE:  White space is not allowed in the data of

		//  property tag or values.  If included, according

		//  to RFC 2614, Section 2.1 these MUST be escaped, 

		//  ie. space would be represented with '\20'.  

		//  Therefore, it is *completely* safe to perform 

		//  these trim()s.  They will catch errors resulting 

		//  from sloppy data entry in slp.conf files and 

		//  never corrupt or alter correctly formatted 

		//  properties.

		SLPTokenizer tk = new SLPTokenizer(ln, "=");

		if (!tk.hasMoreTokens()) {// empty line...

		    continue;

		}

		String prop = tk.nextToken().trim();

		if (prop.trim().length() <= 0) {// line has just spaces...

		    continue;

		}

		if (!tk.hasMoreTokens()) {// line has no definition...

		    continue;

		}

		// Register the property.

		String def = tk.nextToken().trim();

		this.setProperty(prop, def);

	    }

	}

    }

    protected SLPConfig() {

	// Create a temporary, default log to report any errors during

	//  configuration.

	log = new StderrLog();

	// Initialize properties. Properties on command line override config

	//  file properties, and both override defaults.

	Properties sysProps = (Properties)(System.getProperties().clone());

	// Load Defalts.

	try {

	    Class.forName("com.sun.slp.Defaults");

	} catch (ClassNotFoundException ex) {

	    Assert.printMessageAndDie(this,

				      "no_class",

				      new Object[] {"com.sun.slp.Defaults"});

	}

	// System properties now contain Defaults

	Properties defaultProps = System.getProperties();

	// Load config file.

	SLPProperties slpProps = new SLPProperties(new Properties());

	try {

	    InputStream fis = getConfigURLStream();

	    if (fis != null) {

		slpProps.load(fis);

		System.setProperties(slpProps);

	    }

	} catch (IOException ex) {

	    writeLog("unparsable_config_file",

		     new Object[] {ex.getMessage()});

	}

	// Add config properties to Defaults, overwritting any pre-existing

	//  entries

	defaultProps.putAll(slpProps);

	// Now add in system props, overwritting any pre-existing entries

	defaultProps.putAll(sysProps);

	System.setProperties(defaultProps);

	// Initialize useScopes property. This is read-only after the file

	//  has been loaded.

	configuredScopes = initializeScopes("net.slp.useScopes");

	saConfiguredScopes = (Vector)configuredScopes.clone();

	// Add default scope to scopes for SA.

	if (saConfiguredScopes.size() <= 0) {

	    saConfiguredScopes.addElement(Defaults.DEFAULT_SCOPE);

	}

	// Initialize SA scopes. This uses a Sun specific property for

	//  scopes only used by the SA and adds in the DA scopes.

	saOnlyScopes = initializeScopes(DATable.SA_ONLY_SCOPES_PROP);

	// Initialized preconfigured DAs.

	preconfiguredDAs = initializePreconfiguredDAs();

	// Initialize broadcast flag.

	broadcastOnly = Boolean.getBoolean("net.slp.isBroadcastOnly");

	// Initialize logging. Default is stderr, first check for alternate.

	String failed = null;

	try {

	    String loggerClassName =

		System.getProperty("sun.net.slp.loggerClass");

	    if (loggerClassName != null) {

		Class loggerClass = Class.forName(loggerClassName);

		// Protect against disastrous pilot error, such as trying

		// to use com.sun.slp.SLPConfig as the log class

		// (causes stack recursion)

		if (Class.forName("java.io.Writer").isAssignableFrom(

							loggerClass)) {

		    Object logger = loggerClass.newInstance();

		    log = (Writer) logger;

		} else {

		    failed = formatMessage(

					   "bad_log_class",

					   new Object[] {

			loggerClass.toString()}) + "\n";

		}

	    }

	} catch (Throwable ex) {

	    log = null;

	    failed = formatMessage(

				   "bad_log",

				   new Object[] {

		ex.toString()}) + "\n";

	}

	// If no alternate log, revert to minimal default

	if (log == null) {

	    log = new StderrLog();

	    // If the alternate log failed, log it through the default log

	    if (failed != null) {

		try {

		    synchronized (log) {

			log.write(failed);

			log.flush();

		    }

		} catch (IOException giveUp) {}

	    }

	}

    }

    private InputStream getConfigURLStream() {

	// Open a URL onto the configuration file.

	String conf = System.getProperty("sun.net.slp.configURL");

	if (conf == null) {

	    conf = Defaults.SOLARIS_CONF;

	}

	InputStream str = null;

	try {

	    URL confURL = new URL(conf);

	    str = confURL.openStream();

	} catch (MalformedURLException ex) {

	    writeLog("url_malformed",

		     new Object[] {conf});

	} catch (IOException ex) {

	    if (conf != Defaults.SOLARIS_CONF) {

		// don't complain if we can't find our own default

		writeLog("unparsable_config_file",

			 new Object[] {ex.getMessage()});

	    }

	}

	return str;

    }

    // ------------------------------------------------------------

    // Property manipulation functions

    //

    private boolean OKBound(int i, int lb, int ub) {

	if (i < lb || i > ub)

	    return false;

	else

	    return true;

    }

    int getIntProperty(String prop, int df, int lb, int ub) {

	int i = Integer.getInteger(prop, df).intValue();

	if (OKBound(i, lb, ub)) {

	    return i;

	} else {

	    writeLog("bad_prop_tag", new Object[] {prop});

	    return df;

	}

    }

    // ------------------------------------------------------------

    // Multicast radius

    //

    private int iMinMCRadius = 1;   // link local scope

    private int iMaxMCRadius = 255; // universal scope

    int getMCRadius() {

	return getIntProperty("net.slp.multicastTTL",

			      Defaults.iMulticastRadius,

			      iMinMCRadius,

			      iMaxMCRadius);

    }

    // ------------------------------------------------------------

    // Heartbeat interval, seconds.

    //

    private final int iMinHeart = 2000;    // 10 minutes

    private final int iMaxHeart = 259200000; // 3 days

    int getAdvertHeartbeatTime() {

	return getIntProperty("net.slp.DAHeartBeat",

			      Defaults.iHeartbeat,

			      iMinHeart,

			      iMaxHeart);

    }

    // ------------------------------------------------------------

    // Active discovery interval, seconds.

    //

    private final int iMinDisc = 300;    // 5 minutes

    private final int iMaxDisc = 10800;  // 3 hours

    int getActiveDiscoveryInterval() {

	// We allow zero in order to turn active discovery off, but

	//  if 5 minutes is the smallest actual time.

	int prop = getIntProperty("net.slp.DAActiveDiscoveryInterval",

				  Defaults.iActiveDiscoveryInterval,

				  0,

				  iMaxDisc);

	if (prop > 0 && prop < iMinDisc) {

	    writeLog("bad_prop_tag",

		     new Object[] {"net.slp.DAActiveDiscoveryInterval"});

	    return iMinDisc;

	}

	return prop;

    }

    // ------------------------------------------------------------

    // Active discovery granularity, seconds.

    //

    private int iMaxDiscGran = iMaxDisc * 2;

    int getActiveDiscoveryGranularity() {

	return getIntProperty("sun.net.slp.DAActiveDiscoveryGranularity",

			      Defaults.iActiveDiscoveryGranularity,

			      0,

			      iMaxDiscGran);

    }

    // ------------------------------------------------------------

    // Bound for random wait, milliseconds.

    //

    private final int iMinWait = 1000;  // 1 sec.

    private final int iMaxWait = 3000;  // 3 sec.

    int getRandomWaitBound() {

	return getIntProperty("net.slp.randomWaitBound",

			      Defaults.iRandomWaitBound,

			      iMinWait,

			      iMaxWait);

    }

    private static Random randomWait = null;

    long getRandomWait() {

	if (randomWait == null) {

	    randomWait = new Random();

	}

	double r = randomWait.nextDouble();

	double max = (double)getRandomWaitBound();

	return (long)(max * r);

    }

    // ------------------------------------------------------------

    // TCP timeout, milliseconds.

    //

    final static private int iMinTimeout = 100;

    final static private int iMaxTimeout = 360000;

    int getTCPTimeout() {

	return getIntProperty("sun.net.slp.TCPTimeout",

			      Defaults.iTCPTimeout,

			      iMinTimeout,

			      iMaxTimeout);

    }

    // ------------------------------------------------------------

    //  Path MTU

    //

    private final int iMinMTU = 128; // used for some ppp connections

    private final int iMaxMTU = 8192; // used on some LANs

    int getMTU() {

	return getIntProperty("net.slp.MTU",

			      Defaults.iMTU,

			      iMinMTU,

			      iMaxMTU);

    }

    // ------------------------------------------------------------

    // Serialized registrations.

    //

    String getSerializedRegURL() {

	return System.getProperty("net.slp.serializedRegURL", null);

    }

    // ------------------------------------------------------------

    // Are we running as a DA or SA server?

    //

    protected static boolean isSA = false;

    boolean isDA() {

	return false;

    }

    boolean isSA() {

	return isSA;

    }

    // ------------------------------------------------------------

    // DA and SA attributes

    //

    Vector getDAAttributes() {

	return getAttributes("net.slp.DAAttributes",

			     Defaults.defaultDAAttributes,

			     true);

    }

    Vector getSAAttributes() {

	return getAttributes("net.slp.SAAttributes",

			     Defaults.defaultSAAttributes,

			     false);

    }

    private Vector getAttributes(String prop,

				 Vector defaults,

				 boolean daAttrs) {

	String attrList =

	    System.getProperty(prop);

	if (attrList == null || attrList.length() <= 0) {

	    return (Vector)defaults.clone();

	}

	try {

	    Vector sAttrs =

		SrvLocHeader.parseCommaSeparatedListIn(attrList, false);

	    Vector attrs = new Vector();

	    int i, n = sAttrs.size();

	    // Create attribute objects.

	    for (i = 0; i < n; i++) {

		String attrExp = (String)sAttrs.elementAt(i);

		ServiceLocationAttribute attr =

		    new ServiceLocationAttribute(attrExp, false);

		// If this is the min-refresh-interval, then check the value.

		if (daAttrs &&

		    attr.getId().equals(

				Defaults.MIN_REFRESH_INTERVAL_ATTR_ID)) {

		    Vector values = attr.getValues();

		    boolean errorp = true;

		    if (values != null && values.size() == 1) {

			Object val = values.elementAt(0);

			if (val instanceof Integer) {

			    int ival = ((Integer)val).intValue();

			    if (ival >= 0 &&

				ival <= ServiceURL.LIFETIME_MAXIMUM) {

				errorp = false;

			    }

			}

		    }