/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * 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;

                            }
                        }
                    }

                    // Throw exception if it didn't work.

                    if (errorp) {
                        throw new ServiceLocationException(
                                ServiceLocationException.PARSE_ERROR,
                                "syntax_error_prop",
                                new Object[] {prop, attrs});

                    }
                }

                // Add attribute to vector.

                attrs.addElement(attr);

            }

            return attrs;

        } catch (Exception ex) {

            writeLog("syntax_error_prop",
                     new Object[] {prop, attrList});
            return (Vector)defaults.clone();

        }
    }

    // -------------------------------------------------------------
    // Do we support V1?
    //

    boolean isV1Supported() {
        return false;
    }

    // -------------------------------------------------------------
    // Queue length for server socket.
    //

    int getServerSocketQueueLength() {
        return getIntProperty("sun.net.slp.serverSocketQueueLength",
                              Defaults.iSocketQueueLength,
                              0,
                              Integer.MAX_VALUE);
    }

    // ------------------------------------------------------------
    // Testing options
    //


    boolean traceAll() {// not official!
        return Boolean.getBoolean("sun.net.slp.traceALL");
    }

    boolean regTest() {
        if (Boolean.getBoolean("sun.net.slp.traceALL") ||
            Boolean.getBoolean("net.slp.traceReg"))
            return true;
        else
            return false;
    }

    boolean traceMsg() {
        if (Boolean.getBoolean("sun.net.slp.traceALL") ||
            Boolean.getBoolean("net.slp.traceMsg"))
            return true;
        else
            return false;
    }

    boolean traceDrop() {
        if (Boolean.getBoolean("sun.net.slp.traceALL") ||
            Boolean.getBoolean("net.slp.traceDrop"))
            return true;
        else
            return false;
    }

    boolean traceDATraffic() {
        if (Boolean.getBoolean("sun.net.slp.traceALL") ||
            Boolean.getBoolean("net.slp.traceDATraffic"))
            return true;
        else
            return false;
    }

    // cannot use Boolean.getBoolean as the default is 'true'
    // using that mechanism, absense would be considered 'false'

    boolean passiveDADetection() {

        String sPassive =
            System.getProperty("net.slp.passiveDADetection", "true");
        if (sPassive.equalsIgnoreCase("true"))
            return true;
        else
            return false;

    }

    // Initialized when the SLPConfig object is created to avoid changing
    //  during the program.
    private boolean broadcastOnly = false;

    boolean isBroadcastOnly() {
        return broadcastOnly;
    }


    // ------------------------------------------------------------
    // Multicast/broadcast socket mangement.
    //
    DatagramSocket broadSocket = null;   // cached broadcast socket.


    // Reopen the multicast/broadcast socket bound to the
    //  interface. If groups is not null, then join all
    //  the groups. Otherwise, this is send only.

    DatagramSocket
        refreshMulticastSocketOnInterface(InetAddress interfac,
                                          Vector groups) {

        try {

            // Reopen it.

            DatagramSocket dss =
                getMulticastSocketOnInterface(interfac,
                                              (groups == null ? true:false));

            if ((groups != null) && (dss instanceof MulticastSocket)) {
                int i, n = groups.size();
                MulticastSocket mss = (MulticastSocket)dss;

                for (i = 0; i < n; i++) {
                    InetAddress maddr = (InetAddress)groups.elementAt(i);

                    mss.joinGroup(maddr);

                }
            }

            return dss;

        } catch (Exception ex) {

            // Any exception in error recovery causes program to die.

            Assert.slpassert(false,
                          "cast_socket_failure",
                          new Object[] {ex, ex.getMessage()});

        }

        return null;
    }

    // Open a multicast/broadcast socket on the interface. Note that if
    //  the socket is broadcast, the network interface is not specified in the
    //  creation message. Is it bound to all interfaces? The isSend parameter
    //  specifies whether the socket is for send only.

    DatagramSocket
        getMulticastSocketOnInterface(InetAddress interfac, boolean isSend)
        throws ServiceLocationException {

        DatagramSocket castSocket = null;

        // Substitute broadcast if we are configured for it.

        if (isBroadcastOnly()) {

            try {

                // If transmit, then simply return a new socket.

                if (isSend) {
                    castSocket = new DatagramSocket();

                } else {

                    // Return cached socket if there.

                    if (broadSocket != null) {
                        castSocket = broadSocket;

                    } else {

                        // Make a new broadcast socket.

                        castSocket =
                            new DatagramSocket(Defaults.iSLPPort,
                                               getBroadcastAddress());

                    }

                    // Cache for future reference.

                    broadSocket = castSocket;
                }
            } catch (SocketException ex) {
                throw
                    new ServiceLocationException(
                                ServiceLocationException.NETWORK_INIT_FAILED,
                                "socket_creation_failure",
                                new Object[] {
                        getBroadcastAddress(), ex.getMessage()});
            }

        } else {

            // Create a multicast socket.

            MulticastSocket ms;

            try {

                if (isSend) {
                    ms = new MulticastSocket();

                } else {
                    ms = new MulticastSocket(Defaults.iSLPPort);

                }

            } catch (IOException ex) {
                throw
                    new ServiceLocationException(
                                ServiceLocationException.NETWORK_INIT_FAILED,
                                "socket_creation_failure",
                                new Object[] {interfac, ex.getMessage()});
            }


            try {

                // Set the TTL and the interface on the multicast socket.
                //  Client is responsible for joining group.

                ms.setTimeToLive(getMCRadius());
                ms.setInterface(interfac);

            } catch (IOException ex) {
                throw
                    new ServiceLocationException(
                                ServiceLocationException.NETWORK_INIT_FAILED,
                                "socket_initializtion_failure",
                                new Object[] {interfac, ex.getMessage()});
            }

            castSocket = ms;

        }

        return castSocket;
    }

    // ------------------------------------------------------------
    // Type hint
    //

    // Return a vector of ServiceType objects for the type hint.

    Vector getTypeHint() {
        Vector hint = new Vector();
        String sTypeList = System.getProperty("net.slp.typeHint", "");

        if (sTypeList.length() <= 0) {
            return hint;

        }

        // Create a vector of ServiceType objects for the type hint.

        try {

            hint = SrvLocHeader.parseCommaSeparatedListIn(sTypeList, true);

            int i, n = hint.size();

            for (i = 0; i < n; i++) {
                String type = (String)hint.elementAt(i);

                hint.setElementAt(new ServiceType(type), i);

            }
        } catch (ServiceLocationException ex) {

            writeLog("syntax_error_prop",
                     new Object[] {"net.slp.typeHint", sTypeList});

            hint.removeAllElements();

        }

        return hint;

    }

    // ------------------------------------------------------------
    // Configured scope handling
    //

    // Vector of configured scopes.

    private Vector configuredScopes = null;

    // Vector of configures scopes for SA.

    private Vector saConfiguredScopes = null;

    // Vector of scopes only in the sa server.

    private Vector saOnlyScopes = null;

    // Return the configured scopes.

    Vector getConfiguredScopes() {
        return (Vector)configuredScopes.clone();
    }

    // Return SA scopes.

    Vector getSAOnlyScopes() {
        return (Vector)saOnlyScopes.clone();

    }

    // Return the configured scopes for the SA.

    Vector getSAConfiguredScopes() {
        return (Vector)saConfiguredScopes.clone();

    }

    // Add scopes discovered during preconfigured DA contact.
    //  These count as configured scopes.

    void addPreconfiguredDAScopes(Vector scopes) {

        int i, n = scopes.size();

        for (i = 0; i < n; i++) {
            Object scope = scopes.elementAt(i);

            if (!configuredScopes.contains(scope)) {
                configuredScopes.addElement(scope);

            }

            // There better be none extra here for the SA server/DA.

            if (isSA() || isDA()) {
                Assert.slpassert(saConfiguredScopes.contains(scope),
                              "sa_new_scope",
                              new Object[] {scope, saConfiguredScopes});

            }
        }
    }

    // Initialize the scopes list on property.

    private Vector initializeScopes(String prop) {

        String sScopes = System.getProperty(prop);

        if (sScopes == null || sScopes.length() <= 0) {
            return new Vector();
        }

        try {

            Vector vv =
                SrvLocHeader.parseCommaSeparatedListIn(sScopes, true);

            // Unescape scope strings.

            SLPHeaderV2.unescapeScopeStrings(vv);

            // Validate, lower case scope names.

            DATable.validateScopes(vv, getLocale());

            if (vv.size() > 0) {
                return vv;
            }

        } catch (ServiceLocationException ex) {
            writeLog("syntax_error_prop",
                     new Object[] {
                prop,
                    sScopes});


        }

        return new Vector();
    }

    // Vector of preconfigured DAs. Read only after initialized.

    private Vector preconfiguredDAs = null;

    // Return a vector of DA addresses.

    Vector getPreconfiguredDAs() {
        return (Vector)preconfiguredDAs.clone();

    }

    // Initialize preconfigured DA list.

    private Vector initializePreconfiguredDAs() {
        String sDAList = System.getProperty("net.slp.DAAddresses", "");
        Vector ret = new Vector();

        sDAList.trim();

        if (sDAList.length() <= 0) {
            return ret;

        }

        try {

            ret = SrvLocHeader.parseCommaSeparatedListIn(sDAList, true);

        } catch (ServiceLocationException ex) {

            writeLog("syntax_error_prop",
                     new Object[] {"net.slp.DAAddress", sDAList});

            return ret;

        }

        // Convert to InetAddress objects.

        int i;

        for (i = 0; i < ret.size(); i++) {
            String da = "";

            try {
                da = ((String)ret.elementAt(i)).trim();
                InetAddress daAddr = InetAddress.getByName(da);

                ret.setElementAt(daAddr, i);

            } catch (UnknownHostException ex) {

                writeLog("resolve_failed",
                         new Object[] {da});

                /*
                 *  Must decrement the index 'i' otherwise the next iteration
                 *  around the loop will miss the element immediately after
                 *  the element removed.
                 *
                 *  WARNING: Do not use 'i' again until the loop has
                 *           iterated as it may, after decrementing,
                 *           be negative.
                 */
                ret.removeElementAt(i);
                i--;
                continue;
            }
        }


        return ret;
    }

    // ------------------------------------------------------------
    // SLPv1 Support Switches
    //

    boolean getSLPv1NotSupported() {// not official!
        return Boolean.getBoolean("sun.net.slp.SLPv1NotSupported");

    }

    boolean getAcceptSLPv1UnscopedRegs() {// not official!

        if (!getSLPv1NotSupported()) {
            return Boolean.getBoolean("sun.net.slp.acceptSLPv1UnscopedRegs");

        }

        return false;
    }

    // ------------------------------------------------------------
    // Accessor for SLPConfig object
    //

    protected static SLPConfig theSLPConfig = null;

    static SLPConfig getSLPConfig() {

        if (theSLPConfig == null) {
            theSLPConfig = new SLPConfig();
        }

        return theSLPConfig;

    }

    /**
     * @return Maximum number of messages/objects to return.
     */

    int getMaximumResults()  {
        int i = Integer.getInteger("net.slp.maxResults",
                                   Defaults.iMaximumResults).intValue();
        if (i == -1) {
            i = Integer.MAX_VALUE;

        }

        if (OKBound(i, 1, Integer.MAX_VALUE)) {
            return i;

        } else {

            writeLog("bad_prop_tag",
                     new Object[] {
                "net.slp.maxResults"});

            return Defaults.iMaximumResults;

        }
    }

    /**
     * Convert a language tag into a locale.
     */

    static Locale langTagToLocale(String ltag) {

        // We treat the first part as the ISO 639 language and the
        // second part as the ISO 3166 country tag, even though RFC
        // 1766 doesn't necessarily require that. We should probably
        // use a lookup table here to determine if they are correct.

        StringTokenizer tk = new StringTokenizer(ltag, "-");
        String lang = "";
        String country = "";

        if (tk.hasMoreTokens()) {
            lang = tk.nextToken();

            if (tk.hasMoreTokens()) {
                country = tk.nextToken("");
                                        // country name may have "-" in it...

            }
        }

        return new Locale(lang, country);
    }

    /**
     * Convert a Locale object into a language tag for output.
     *
     * @param locale The Locale.
     * @return String with the language tag encoded.
     */

    static String localeToLangTag(Locale locale) {

        // Construct the language tag.

        String ltag = locale.getCountry();
        ltag = locale.getLanguage() + (ltag.length() <= 0 ? "" : ("-" + ltag));

        return ltag;

    }

    /**
     * @return the language requests will be made in.
     */
    static Locale  getLocale()    {
        String s = System.getProperty("net.slp.locale");

        if (s != null && s.length() > 0) {
            return langTagToLocale(s);

        } else {

            // Return the Java default if the SLP property is not set.

            return Locale.getDefault();

        }
    }

    /**
     * @return the InetAddress of the broadcast interface.
     */

    static private InetAddress broadcastAddress;

    static InetAddress getBroadcastAddress() {
        if (broadcastAddress == null) {

            try {
                broadcastAddress =
                    InetAddress.getByName(Defaults.sBroadcast);
            } catch (UnknownHostException uhe) {

                Assert.slpassert(false,
                              "cast_address_failure",
                              new Object[] {Defaults.sBroadcast});

            }
        }
        return broadcastAddress;
    }


    /**
     * @return the InetAddress of the multicast group.
     */

    static private InetAddress multicastAddress;

    static InetAddress getMulticastAddress() {
        if (multicastAddress == null) {

            try {
                multicastAddress =
                    InetAddress.getByName(Defaults.sGeneralSLPMCAddress);
            } catch (UnknownHostException uhe) {
                Assert.slpassert(false,
                              "cast_address_failure",
                              new Object[] {Defaults.sGeneralSLPMCAddress});

            }
        }
        return multicastAddress;
    }

    /**
     * @return the interfaces on which SLP should listen and transmit.
     */

    private static Vector interfaces = null;

    Vector getInterfaces() {

        if (interfaces == null) {
            InetAddress iaLocal = null;

            // Get local host.

            try {
                iaLocal =  InetAddress.getLocalHost();

            }  catch (UnknownHostException ex) {
                Assert.slpassert(false,
                              "resolve_failed",
                              new Object[] {"localhost"});
            }

            String mcastI = System.getProperty("net.slp.interfaces");
            interfaces = new Vector();

            // Only add local host if nothing else is given.

            if (mcastI == null || mcastI.length() <= 0) {
                interfaces.addElement(iaLocal);
                return interfaces;

            }

            Vector nintr;

            try {

                nintr = SrvLocHeader.parseCommaSeparatedListIn(mcastI, true);

            } catch (ServiceLocationException ex) {
                writeLog("syntax_error_prop",
                         new Object[] {
                    "net.slp.multicastInterfaces",
                        mcastI});

                // Add local host.

                interfaces.addElement(iaLocal);

                return interfaces;

            }

            // See if they are really there.

            int i, n = nintr.size();

            for (i = 0; i < n; i++) {
                InetAddress ia;
                String host = (String)nintr.elementAt(i);

                try {

                    ia = InetAddress.getByName(host);

                } catch (UnknownHostException ex) {
                    writeLog("unknown_interface",
                             new Object[] {host,
                                               "net.slp.multicastInterfaces"});
                    continue;

                }

                if (!interfaces.contains(ia)) {

                    // Add default at beginning.

                    if (ia.equals(iaLocal)) {
                        interfaces.insertElementAt(ia, 0);

                    } else {
                        interfaces.addElement(ia);

                    }
                }
            }
        }

        return interfaces;

    }

    /**
     * @return An InetAddress object representing 127.0.0.1
     */
    InetAddress getLoopback() {
        InetAddress iaLoopback = null;

        try {
            iaLoopback = InetAddress.getByName(Defaults.LOOPBACK_ADDRESS);

        }  catch (UnknownHostException ex) {
            Assert.slpassert(false,
                          "resolve_failed",
                          new Object[] {"localhost loopback"});
        }

        return iaLoopback;
    }

    /**
     * @return The default interface, which should be the first in the
     *         interfaces vector Vector.
     */

    InetAddress getLocalHost() {
        Vector inter = getInterfaces();
        return (InetAddress)inter.elementAt(0);

    }

    // Return true if the address is one of the local interfaces.

    boolean isLocalHostSource(InetAddress addr) {

        // First check loopback

        if (addr.equals(getLoopback())) {
            return true;

        }

        return interfaces.contains(addr);

    }

    // -----------------
    // Timeouts
    //

    // Return the maximum wait for multicast convergence.

    final static private int iMultiMin = 1000;  // one second
    final static private int iMultiMax = 60000; // one minute

    int getMulticastMaximumWait() {

        return getIntProperty("net.slp.multicastMaximumWait",
                              Defaults.iMulticastMaxWait,
                              iMultiMin,
                              iMultiMax);
    }

    /*
     * @return Vector of timeouts for multicast convergence.
     */

    int[] getMulticastTimeouts() {
        int[] timeouts = parseTimeouts("net.slp.multicastTimeouts",
                             Defaults.a_iConvergeTimeout);

        timeouts = capTimeouts("net.slp.multicastTimeouts",
                               timeouts,
                               false,
                               0,
                               0);

        return timeouts;
    }

    /**
     * @return Vector of timeouts to try for datagram transmission.
     */

    int[] getDatagramTimeouts() {
        int[] timeouts = parseTimeouts("net.slp.datagramTimeouts",
                             Defaults.a_iDatagramTimeout);

        timeouts = capTimeouts("net.slp.datagramTimeouts",
                               timeouts,
                               true,
                               iMultiMin,
                               iMultiMax);

        return timeouts;
    }

    /**
     * @return Vector of timeouts for DA discovery multicast.
     */

    int[] getDADiscoveryTimeouts() {
        int[] timeouts = parseTimeouts("net.slp.DADiscoveryTimeouts",
                             Defaults.a_iDADiscoveryTimeout);

        timeouts = capTimeouts("net.slp.DADiscoveryTimeouts",
                                timeouts,
                                false,
                                0,
                                0);

        return timeouts;
    }

    /**
     *  This method ensures that all the timeouts are within valid ranges.
     *  The sum of all timeouts for the given property name must not
     *  exceed the value returned by <i>getMulticastMaximumWait()</i>. If
     *  the sum of all timeouts does exceed the maximum wait period the
     *  timeouts are averaged out so that the sum equals the maximum wait
     *  period.
     *  <br>
     *  Additional range checking is also performed when <i>rangeCheck</i>
     *  is true. Then the sum of all timeouts must also be between <i>min</i>
     *  and <i>max</i>. If the sum of all timeouts is not within the range
     *  the average is taken from the closest range boundary.
     *
     *  @param property
     *      Name of timeout property being capped. This is only present for
     *      reporting purposes and no actual manipulation of the property
     *      is made within this method.
     *  @param timeouts
     *      Array of timeout values.
     *  @param rangeCheck
     *      Indicator of whether additional range checking is required. When
     *      false <i>min</i> and <i>max</i> are ignored.
     *  @param min
     *      Additional range checking lower boundary.
     *  @param max
     *      Additional range checking upper boundary.
     *  @return
     *      Array of capped timeouts. Note this may be the same array as
     *      passed in (<i>timeouts</i>).
     */
    private int[] capTimeouts(String property,
                              int[] timeouts,
                              boolean rangeCheck,
                              int min,
                              int max) {

        int averagedTimeout;
        int totalWait = 0;

        for (int index = 0; index < timeouts.length; index++) {
            totalWait += timeouts[index];
        }

        if (rangeCheck) {
            // If sum of timeouts within limits then finished.
            if (totalWait >= min && totalWait <= max) {
                return timeouts;
            }

            // Average out the timeouts so the sum is equal to the closest
            // range boundary.
            if (totalWait < min) {
                averagedTimeout = min / timeouts.length;
            } else {
                averagedTimeout = max / timeouts.length;
            }

            writeLog("capped_range_timeout_prop",
                     new Object[] {property,
                                   String.valueOf(totalWait),
                                   String.valueOf(min),
                                   String.valueOf(max),
                                   String.valueOf(timeouts.length),
                                   String.valueOf(averagedTimeout)});
        } else {
            // Sum of all timeouts must not exceed this value.
            int maximumWait = getMulticastMaximumWait();

            // If sum of timeouts within limits then finished.
            if (totalWait <= maximumWait) {
                return timeouts;
            }

            // Average out the timeouts so the sum is equal to the maximum
            // timeout.
            averagedTimeout = maximumWait / timeouts.length;

            writeLog("capped_timeout_prop",
                     new Object[] {property,
                                   String.valueOf(totalWait),
                                   String.valueOf(maximumWait),
                                   String.valueOf(timeouts.length),
                                   String.valueOf(averagedTimeout)});
        }

        for (int index = 0; index < timeouts.length; index++) {
            timeouts[index] = averagedTimeout;
        }

        return timeouts;
    }

    private int[] parseTimeouts(String property, int[] defaults) {

        String sTimeouts = System.getProperty(property);

        if (sTimeouts == null || sTimeouts.length() <= 0) {
            return defaults;

        }

        Vector timeouts = null;

        try {
            timeouts = SrvLocHeader.parseCommaSeparatedListIn(sTimeouts, true);

        } catch (ServiceLocationException ex) {
            writeLog("syntax_error_prop",
                     new Object[] {property, sTimeouts});
            return defaults;

        }

        int iCount = 0;
        int[] iTOs = new int[timeouts.size()];

        for (Enumeration en = timeouts.elements(); en.hasMoreElements(); ) {
            String s1 = (String)en.nextElement();

            try {
                iTOs[iCount] = Integer.parseInt(s1);

            }   catch (NumberFormatException nfe) {
                writeLog("syntax_error_prop",
                         new Object[] {property, sTimeouts});
                return defaults;

            }

            if (iTOs[iCount] < 0) {
                writeLog("invalid_timeout_prop",
                         new Object[] {property, String.valueOf(iTOs[iCount])});
                return defaults;
            }

            iCount++;
        }

        return iTOs;
    }

    // -----------------------------
    // SLP Time Calculation
    //

    /**
     * Returns the number of seconds since 00:00 Universal Coordinated
     * Time, January 1, 1970.
     *
     * Java returns the number of milliseconds, so all the method does is
     * divide by 1000.
     *
     * This implementation still will have a problem when the Java time
     * values wraps, but there isn't much we can do now.
     */
    static long currentSLPTime() {
        return (System.currentTimeMillis() / 1000);
    }

    /* security */

    // Indicates whether security class is available.

    boolean getSecurityEnabled() {
        return securityEnabled;

    }

    private static boolean securityEnabled;

    // Indicates whether the securityEnabled property is true

    boolean getHasSecurity() {
        return securityEnabled &&
            (Boolean.valueOf(System.getProperty("net.slp.securityEnabled",
                                            "false")).booleanValue());
    }

    // I18N Support.

    private static final String BASE_BUNDLE_NAME = "com/sun/slp/ClientLib";

    ResourceBundle getMessageBundle(Locale locale) {

        ResourceBundle msgBundle = null;

        // First try the Solaris Java locale area

        try {
            URL[] urls = new URL[] {new URL("file:/usr/share/lib/locale/")};

            URLClassLoader ld = new URLClassLoader(urls);

            msgBundle = ResourceBundle.getBundle(BASE_BUNDLE_NAME, locale, ld);

            return msgBundle;
        } catch (MalformedURLException e) {     // shouldn't get here
        } catch (MissingResourceException ex) {
            System.err.println("Missing resource bundle ``"+
                               "/usr/share/lib/locale/" + BASE_BUNDLE_NAME +
                               "'' for locale ``" +
                               locale + "''; trying default...");
        }

        try {
            msgBundle = ResourceBundle.getBundle(BASE_BUNDLE_NAME, locale);

        } catch (MissingResourceException ex) {  // can't localize this one!

            // We can't print out to the log, because we may be in the
            //  process of trying to.

            System.err.println("Missing resource bundle ``"+
                               BASE_BUNDLE_NAME+
                               "'' for locale ``"+
                               locale+
                               "''");
            // Hosed if the default locale is missing.

            if (locale.equals(Defaults.locale)) {

                System.err.println("Exiting...");
                System.exit(1);
            }

            // Otherwise, return the default locale.

            System.err.println("Using SLP default locale ``" +
                               Defaults.locale +
                               "''");

            msgBundle = getMessageBundle(Defaults.locale);

        }

        return msgBundle;
    }

    String formatMessage(String msgTag, Object[] params) {
        ResourceBundle bundle = getMessageBundle(getLocale());
        return formatMessageInternal(msgTag, params, bundle);

    }

    // MessageFormat is picky about types. Convert the params into strings.

    static void convertToString(Object[] params) {
        int i, n = params.length;

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

            if (params[i] != null) {
                params[i] = params[i].toString();

            } else {
                params[i] = "<null>";

            }
        }
    }

    static String
        formatMessageInternal(String msgTag,
                              Object[] params,
                              ResourceBundle bundle) {
        String pattern = "";

        try {
            pattern = bundle.getString(msgTag);

        } catch (MissingResourceException ex) {

            // Attempt to report error. Can't use Assert here because it
            //  calls back into SLPConfig.
            String msg = "Can''t find message ``{0}''''.";

            try {
                pattern = bundle.getString("cant_find_resource");
                msg = MessageFormat.format(pattern, new Object[] {msgTag});

            } catch (MissingResourceException exx) {

            }

            System.err.println(msg);
            System.exit(-1);
        }

        convertToString(params);

        return MessageFormat.format(pattern, params);
    }

    // logging.

    // Protected so slpd can replace it.

    protected Writer log;

    // Synchronized so writes from multiple threads don't get interleaved.

    void writeLog(String msgTag, Object[] params) {

        // MessageFormat is picky about types. Convert the params into strings.

        convertToString(params);

        try {
            synchronized (log) {
                log.write(formatMessage(msgTag, params));
                log.flush();
            }
        } catch (IOException ex) {}
    }

    void writeLogLine(String msgTag, Object[] params) {

        try {
            String pattern = getMessageBundle(getLocale()).getString(msgTag);

            synchronized (log) {
                log.write(formatMessage(msgTag, params));
                log.write("\n");
                log.flush();
            }
        } catch (IOException ex) {}

    }

    static String getDateString() {

        DateFormat df = DateFormat.getDateTimeInstance(DateFormat.DEFAULT,
                                                       DateFormat.DEFAULT,
                                                       getLocale());
        Calendar calendar = Calendar.getInstance(getLocale());
        return df.format(calendar.getTime());

    }


    // On load, check whether the signature class is available, and turn
    //  security off if not.

    static {

        securityEnabled = true;
        try {
            Class c = Class.forName("com.sun.slp.AuthBlock");

        } catch (ClassNotFoundException e) {
            securityEnabled = false;
        }
    }

}