/* * CDDL HEADER START * * The contents of this file are subject to the terms of the * Common Development and Distribution License, Version 1.0 only * (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 */ /* * ident "%Z%%M% %I% %E% SMI" * * Copyright 1999-2003 Sun Microsystems, Inc. All rights reserved. * Use is subject to license terms. * */ // SCCS Status: @(#)SLPConfig.java 2.4 10/07/97 // 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 getMulticastMaximumWait(). 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. *
* Additional range checking is also performed when rangeCheck * is true. Then the sum of all timeouts must also be between min * and max. 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 min and max 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 (timeouts). */ 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 && (new Boolean(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] = ""; } } } 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; } } }