436 lines
15 KiB
Java
436 lines
15 KiB
Java
/**
|
|
*
|
|
* Copyright 2003-2007 Jive Software.
|
|
*
|
|
* All rights reserved. Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
package org.jivesoftware.smack;
|
|
|
|
import java.io.IOException;
|
|
import java.io.InputStream;
|
|
import java.util.ArrayList;
|
|
import java.util.Collection;
|
|
import java.util.Collections;
|
|
import java.util.List;
|
|
import java.util.logging.Level;
|
|
import java.util.logging.Logger;
|
|
|
|
import org.jivesoftware.smack.parsing.ExceptionThrowingCallback;
|
|
import org.jivesoftware.smack.parsing.ParsingExceptionCallback;
|
|
import org.jivesoftware.smack.util.FileUtils;
|
|
import org.xmlpull.mxp1.MXParser;
|
|
import org.xmlpull.v1.XmlPullParser;
|
|
|
|
/**
|
|
* Represents the configuration of Smack. The configuration is used for:
|
|
* <ul>
|
|
* <li> Initializing classes by loading them at start-up.
|
|
* <li> Getting the current Smack version.
|
|
* <li> Getting and setting global library behavior, such as the period of time
|
|
* to wait for replies to packets from the server. Note: setting these values
|
|
* via the API will override settings in the configuration file.
|
|
* </ul>
|
|
*
|
|
* Configuration settings are stored in META-INF/smack-config.xml (typically inside the
|
|
* smack.jar file).
|
|
*
|
|
* @author Gaston Dombiak
|
|
*/
|
|
public final class SmackConfiguration {
|
|
private static final String SMACK_VERSION = "3.4.0";
|
|
private static final String DEFAULT_CONFIG_FILE = "classpath:META-INF/smack-config.xml";
|
|
|
|
private static final Logger log = Logger.getLogger(SmackConfiguration.class.getName());
|
|
|
|
private static InputStream configFileStream;
|
|
|
|
private static int packetReplyTimeout = 5000;
|
|
private static int keepAliveInterval = 30000;
|
|
private static List<String> defaultMechs = new ArrayList<String>();
|
|
|
|
private static boolean localSocks5ProxyEnabled = true;
|
|
private static int localSocks5ProxyPort = 7777;
|
|
private static int packetCollectorSize = 5000;
|
|
|
|
private static boolean initialized = false;
|
|
|
|
/**
|
|
* The default parsing exception callback is {@link ExceptionThrowingCallback} which will
|
|
* throw an exception and therefore disconnect the active connection.
|
|
*/
|
|
private static ParsingExceptionCallback defaultCallback = new ExceptionThrowingCallback();
|
|
|
|
/**
|
|
* This automatically enables EntityCaps for new connections if it is set to true
|
|
*/
|
|
private static boolean autoEnableEntityCaps = true;
|
|
|
|
private SmackConfiguration() {
|
|
}
|
|
|
|
/**
|
|
* Loads the configuration from the smack-config.xml file.<p>
|
|
*
|
|
* So far this means that:
|
|
* 1) a set of classes will be loaded in order to execute their static init block
|
|
* 2) retrieve and set the current Smack release
|
|
*/
|
|
|
|
/**
|
|
* Sets the location of the config file on the classpath. Only required if changing from the default location of <i>classpath:META-INF/smack-config.xml</i>.
|
|
*
|
|
* <p>
|
|
* This method must be called before accessing any other class in Smack.
|
|
*
|
|
* @param configFileUrl The location of the config file.
|
|
* @param loader The classloader to use if the URL has a protocol of <b>classpath</> and the file is not located on the default classpath.
|
|
* This can be set to null to use defaults and is ignored for all other protocols.
|
|
* @throws IllegalArgumentException If the config URL is invalid in that it cannot open an {@link InputStream}
|
|
*/
|
|
public static void setConfigFileUrl(String configFileUrl, ClassLoader loader) {
|
|
try {
|
|
configFileStream = FileUtils.getStreamForUrl(configFileUrl, loader);
|
|
}
|
|
catch (Exception e) {
|
|
throw new IllegalArgumentException("Failed to create input stream from specified file URL ["+ configFileUrl + "]", e);
|
|
}
|
|
initialize();
|
|
}
|
|
|
|
/**
|
|
* Sets the {@link InputStream} representing the smack configuration file. This can be used to override the default with something that is not on the classpath.
|
|
* <p>
|
|
* This method must be called before accessing any other class in Smack.
|
|
* @param configFile
|
|
*/
|
|
public static void setConfigFileStream(InputStream configFile) {
|
|
configFileStream = configFile;
|
|
initialize();
|
|
}
|
|
|
|
/**
|
|
* Returns the Smack version information, eg "1.3.0".
|
|
*
|
|
* @return the Smack version information.
|
|
*/
|
|
public static String getVersion() {
|
|
return SMACK_VERSION;
|
|
}
|
|
|
|
/**
|
|
* Returns the number of milliseconds to wait for a response from
|
|
* the server. The default value is 5000 ms.
|
|
*
|
|
* @return the milliseconds to wait for a response from the server
|
|
*/
|
|
public static int getPacketReplyTimeout() {
|
|
initialize();
|
|
|
|
// The timeout value must be greater than 0 otherwise we will answer the default value
|
|
if (packetReplyTimeout <= 0) {
|
|
packetReplyTimeout = 5000;
|
|
}
|
|
return packetReplyTimeout;
|
|
}
|
|
|
|
/**
|
|
* Sets the number of milliseconds to wait for a response from
|
|
* the server.
|
|
*
|
|
* @param timeout the milliseconds to wait for a response from the server
|
|
*/
|
|
public static void setPacketReplyTimeout(int timeout) {
|
|
initialize();
|
|
|
|
if (timeout <= 0) {
|
|
throw new IllegalArgumentException();
|
|
}
|
|
packetReplyTimeout = timeout;
|
|
}
|
|
|
|
/**
|
|
* Gets the default max size of a packet collector before it will delete
|
|
* the older packets.
|
|
*
|
|
* @return The number of packets to queue before deleting older packets.
|
|
*/
|
|
public static int getPacketCollectorSize() {
|
|
initialize();
|
|
return packetCollectorSize;
|
|
}
|
|
|
|
/**
|
|
* Sets the default max size of a packet collector before it will delete
|
|
* the older packets.
|
|
*
|
|
* @param The number of packets to queue before deleting older packets.
|
|
*/
|
|
public static void setPacketCollectorSize(int collectorSize) {
|
|
initialize();
|
|
packetCollectorSize = collectorSize;
|
|
}
|
|
|
|
/**
|
|
* Add a SASL mechanism to the list to be used.
|
|
*
|
|
* @param mech the SASL mechanism to be added
|
|
*/
|
|
public static void addSaslMech(String mech) {
|
|
initialize();
|
|
|
|
if(! defaultMechs.contains(mech) ) {
|
|
defaultMechs.add(mech);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Add a Collection of SASL mechanisms to the list to be used.
|
|
*
|
|
* @param mechs the Collection of SASL mechanisms to be added
|
|
*/
|
|
public static void addSaslMechs(Collection<String> mechs) {
|
|
initialize();
|
|
|
|
for(String mech : mechs) {
|
|
addSaslMech(mech);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Remove a SASL mechanism from the list to be used.
|
|
*
|
|
* @param mech the SASL mechanism to be removed
|
|
*/
|
|
public static void removeSaslMech(String mech) {
|
|
initialize();
|
|
defaultMechs.remove(mech);
|
|
}
|
|
|
|
/**
|
|
* Remove a Collection of SASL mechanisms to the list to be used.
|
|
*
|
|
* @param mechs the Collection of SASL mechanisms to be removed
|
|
*/
|
|
public static void removeSaslMechs(Collection<String> mechs) {
|
|
initialize();
|
|
defaultMechs.removeAll(mechs);
|
|
}
|
|
|
|
/**
|
|
* Returns the list of SASL mechanisms to be used. If a SASL mechanism is
|
|
* listed here it does not guarantee it will be used. The server may not
|
|
* support it, or it may not be implemented.
|
|
*
|
|
* @return the list of SASL mechanisms to be used.
|
|
*/
|
|
public static List<String> getSaslMechs() {
|
|
return Collections.unmodifiableList(defaultMechs);
|
|
}
|
|
|
|
/**
|
|
* Returns true if the local Socks5 proxy should be started. Default is true.
|
|
*
|
|
* @return if the local Socks5 proxy should be started
|
|
*/
|
|
public static boolean isLocalSocks5ProxyEnabled() {
|
|
initialize();
|
|
return localSocks5ProxyEnabled;
|
|
}
|
|
|
|
/**
|
|
* Sets if the local Socks5 proxy should be started. Default is true.
|
|
*
|
|
* @param localSocks5ProxyEnabled if the local Socks5 proxy should be started
|
|
*/
|
|
public static void setLocalSocks5ProxyEnabled(boolean localSocks5ProxyEnabled) {
|
|
initialize();
|
|
SmackConfiguration.localSocks5ProxyEnabled = localSocks5ProxyEnabled;
|
|
}
|
|
|
|
/**
|
|
* Return the port of the local Socks5 proxy. Default is 7777.
|
|
*
|
|
* @return the port of the local Socks5 proxy
|
|
*/
|
|
public static int getLocalSocks5ProxyPort() {
|
|
initialize();
|
|
return localSocks5ProxyPort;
|
|
}
|
|
|
|
/**
|
|
* Sets the port of the local Socks5 proxy. Default is 7777. If you set the port to a negative
|
|
* value Smack tries the absolute value and all following until it finds an open port.
|
|
*
|
|
* @param localSocks5ProxyPort the port of the local Socks5 proxy to set
|
|
*/
|
|
public static void setLocalSocks5ProxyPort(int localSocks5ProxyPort) {
|
|
initialize();
|
|
SmackConfiguration.localSocks5ProxyPort = localSocks5ProxyPort;
|
|
}
|
|
|
|
/**
|
|
* Check if Entity Caps are enabled as default for every new connection
|
|
* @return
|
|
*/
|
|
public static boolean autoEnableEntityCaps() {
|
|
initialize();
|
|
return autoEnableEntityCaps;
|
|
}
|
|
|
|
/**
|
|
* Set if Entity Caps are enabled or disabled for every new connection
|
|
*
|
|
* @param true if Entity Caps should be auto enabled, false if not
|
|
*/
|
|
public static void setAutoEnableEntityCaps(boolean b) {
|
|
initialize();
|
|
autoEnableEntityCaps = b;
|
|
}
|
|
|
|
/**
|
|
* Set the default parsing exception callback for all newly created connections
|
|
*
|
|
* @param callback
|
|
* @see ParsingExceptionCallback
|
|
*/
|
|
public static void setDefaultParsingExceptionCallback(ParsingExceptionCallback callback) {
|
|
initialize();
|
|
defaultCallback = callback;
|
|
}
|
|
|
|
/**
|
|
* Returns the default parsing exception callback
|
|
*
|
|
* @return the default parsing exception callback
|
|
* @see ParsingExceptionCallback
|
|
*/
|
|
public static ParsingExceptionCallback getDefaultParsingExceptionCallback() {
|
|
initialize();
|
|
return defaultCallback;
|
|
}
|
|
|
|
private static void parseClassToLoad(XmlPullParser parser) throws Exception {
|
|
String className = parser.nextText();
|
|
// Attempt to load the class so that the class can get initialized
|
|
try {
|
|
Class<?> initClass = Class.forName(className);
|
|
|
|
if (SmackInitializer.class.isAssignableFrom(initClass)) {
|
|
SmackInitializer initializer = (SmackInitializer) initClass.newInstance();
|
|
initializer.initialize();
|
|
}
|
|
}
|
|
catch (ClassNotFoundException cnfe) {
|
|
log.log(Level.WARNING, "A startup class [" + className + "] specified in smack-config.xml could not be loaded: ");
|
|
}
|
|
}
|
|
|
|
private static int parseIntProperty(XmlPullParser parser, int defaultValue)
|
|
throws Exception
|
|
{
|
|
try {
|
|
return Integer.parseInt(parser.nextText());
|
|
}
|
|
catch (NumberFormatException nfe) {
|
|
log.log(Level.SEVERE, "Could not parse integer", nfe);
|
|
return defaultValue;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Order of precedence for config file is VM arg, setConfigXXX methods and embedded default file location.
|
|
*/
|
|
private static void initialize() {
|
|
if (initialized) {
|
|
return;
|
|
}
|
|
initialized = true;
|
|
|
|
String configFileLocation = System.getProperty("smack.config.file");
|
|
|
|
if (configFileLocation != null) {
|
|
try {
|
|
configFileStream = FileUtils.getStreamForUrl(configFileLocation, null);
|
|
}
|
|
catch (Exception e) {
|
|
log.log(Level.SEVERE, "Error creating input stream for config file [" + configFileLocation + "] from VM argument", e);
|
|
}
|
|
}
|
|
|
|
if (configFileStream == null) {
|
|
try {
|
|
configFileStream = FileUtils.getStreamForUrl(DEFAULT_CONFIG_FILE, null);
|
|
}
|
|
catch (Exception e) {
|
|
log.log(Level.INFO, "Could not create input stream for default config file [" + DEFAULT_CONFIG_FILE + "]", e);
|
|
}
|
|
}
|
|
|
|
if (configFileStream != null) {
|
|
readFile(configFileStream);
|
|
}
|
|
else {
|
|
log.log(Level.INFO, "No configuration file found");
|
|
}
|
|
}
|
|
|
|
private static void readFile(InputStream cfgFileStream) {
|
|
try {
|
|
XmlPullParser parser = new MXParser();
|
|
parser.setFeature(XmlPullParser.FEATURE_PROCESS_NAMESPACES, true);
|
|
parser.setInput(cfgFileStream, "UTF-8");
|
|
int eventType = parser.getEventType();
|
|
do {
|
|
if (eventType == XmlPullParser.START_TAG) {
|
|
if (parser.getName().equals("className")) {
|
|
// Attempt to load the class so that the class can get initialized
|
|
parseClassToLoad(parser);
|
|
}
|
|
else if (parser.getName().equals("packetReplyTimeout")) {
|
|
packetReplyTimeout = parseIntProperty(parser, packetReplyTimeout);
|
|
}
|
|
else if (parser.getName().equals("keepAliveInterval")) {
|
|
keepAliveInterval = parseIntProperty(parser, keepAliveInterval);
|
|
}
|
|
else if (parser.getName().equals("mechName")) {
|
|
defaultMechs.add(parser.nextText());
|
|
}
|
|
else if (parser.getName().equals("localSocks5ProxyEnabled")) {
|
|
localSocks5ProxyEnabled = Boolean.parseBoolean(parser.nextText());
|
|
}
|
|
else if (parser.getName().equals("localSocks5ProxyPort")) {
|
|
localSocks5ProxyPort = parseIntProperty(parser, localSocks5ProxyPort);
|
|
}
|
|
else if (parser.getName().equals("packetCollectorSize")) {
|
|
packetCollectorSize = parseIntProperty(parser, packetCollectorSize);
|
|
}
|
|
else if (parser.getName().equals("autoEnableEntityCaps")) {
|
|
autoEnableEntityCaps = Boolean.parseBoolean(parser.nextText());
|
|
}
|
|
}
|
|
eventType = parser.next();
|
|
} while (eventType != XmlPullParser.END_DOCUMENT);
|
|
} catch (Exception e) {
|
|
log.log(Level.SEVERE, "Error occurred while reading config file", e);
|
|
}
|
|
finally {
|
|
try {
|
|
cfgFileStream.close();
|
|
} catch (IOException e) {
|
|
log.log(Level.INFO, "Error while closing config file input stream", e);
|
|
}
|
|
}
|
|
}
|
|
}
|