proxyconfigurationhandler.java

The source code for this package is located in src/gov/nist/sip/proxy. The proxy is a pure JAIN-SIP

/*
 * ProxyHandler.java
 * Used for creating the table containing the association between the method
 * names and the classes processing the corresponding messages.
 * Created on February 3, 2003, 10:52 AM
 */

package gov.nist.sip.proxy;

import org.apache.log4j.Logger;

import org.xml.sax.helpers.DefaultHandler;
import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.XMLReader;

import javax.xml.parsers.SAXParserFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.parsers.SAXParser;
import java.io.*;
import java.util.*;
import gov.nist.sip.proxy.registrar.*;

/**
 * 
 * @author deruelle
 */
public class ProxyConfigurationHandler extends DefaultHandler {

	private static Logger logger = Logger
			.getLogger(ProxyConfigurationHandler.class);

	private Configuration configuration;

	private String element;

	private void configurationMessage(String message) {

		System.out.println(element + ":" + message);

	}

	/** Creates a new instance of ProxyHandler */
	public ProxyConfigurationHandler(String confFile) {
		try {
			SAXParserFactory saxParserFactory = SAXParserFactory.newInstance();

			XMLReader saxParser = saxParserFactory.newSAXParser()
					.getXMLReader();

			saxParser.setContentHandler(this);

			saxParser
					.setFeature("http://xml.org/sax/features/validation", true);

			saxParser.parse(confFile);

		} catch (SAXException sxe) {
			sxe.printStackTrace();
		} catch (IOException ioe) {
			// I/O error
			ioe.printStackTrace();
		} catch (Exception pce) {
			// Parser with specified options can't be built
			pce.printStackTrace();
		}
	}

	public Configuration getConfiguration() {
		return configuration;
	}

	// ===========================================================
	// SAX DocumentHandler methods
	// ===========================================================

	public void startDocument() throws SAXException {
		try {
			logger.debug("---------------------------------------");
			logger.debug("Parsing the XML configuration file...");

			configuration = new Configuration();
		} catch (Exception e) {
			throw new SAXException("XMLRegistrationsParser error", e);
		}
	}

	public void endDocument() throws SAXException {
		try {
			logger
					.debug("The XML configuration file has been successfully parsed!");
			logger.debug("---------------------------------------");
		} catch (Exception e) {
			throw new SAXException("XMLRegistrationsParser error", e);
		}
	}

	public void startElement(String namespaceURI, String lName, // local name
			String qName, // qualified name
			Attributes attrs) throws SAXException {
		String element = qName;
		this.element = element;

		if (element.compareToIgnoreCase("SIP_STACK") == 0) {

			String stackName = attrs.getValue("stack_name");
			if (stackName == null || stackName.trim().equals("")) {
				configurationMessage("ERROR: the name of the stack is not set");

			} else {
				configuration.stackName = stackName.trim();
				configurationMessage("INFORMATION: the name of the stack is set to:"
						+ configuration.stackName);
			}

			String stackIPAddress = attrs.getValue("stack_IP_address");
			if (stackIPAddress == null || stackIPAddress.trim().equals("")) {
				configurationMessage("ERROR: the IP address of the stack is not set");

			} else {
				configuration.stackIPAddress = stackIPAddress.trim();
				configurationMessage("INFORMATION: the stack IP address is set to:"
						+ stackIPAddress);
			}

			String outboundProxy = attrs.getValue("outbound_proxy");
			if (outboundProxy == null || outboundProxy.trim().equals("")) {
				configurationMessage("INFORMATION: the outbound proxy is not set");
			} else {
				configuration.outboundProxy = outboundProxy.trim();
				configurationMessage("INFORMATION: the outbound proxy is "
						+ outboundProxy);
			}

			String routerPath = attrs.getValue("router_path");
			if (routerPath == null || routerPath.trim().equals("")) {
				configurationMessage("WARNING: the path for the router is not set using default");
			} else {
				configuration.routerPath = routerPath.trim();
				configurationMessage("INFORMATION: the path for the router is set to: "
						+ routerPath.trim());
			}

			String extensionMethods = attrs.getValue("extension_methods");
			if (extensionMethods == null || extensionMethods.trim().equals("")) {
				configurationMessage("INFORMATION: no extensions are supported");
			} else {
				configuration.extensionMethods = extensionMethods.trim();
				configurationMessage("INFORMATION: extensions supported: "
						+ extensionMethods);
			}

			
			String stopTime = attrs.getValue("stop_after");
			if (stopTime != null && !stopTime.trim().equals("")) {
				configurationMessage("INFORMATION: The proxy will stop automatically after "
						+ stopTime + " ms");
				configuration.stopTime = stopTime.trim();
			}

			String maxConnections = attrs.getValue("max_connections");
			if (maxConnections != null && !maxConnections.trim().equals("")) {
				configurationMessage("INFORMATION: The proxy will authorize only "
						+ maxConnections + " connections");
				configuration.maxConnections = maxConnections.trim();
			}

			String maxServerTransactions = attrs
					.getValue("max_server_transactions");
			if (maxServerTransactions != null
					&& !maxServerTransactions.trim().equals("")) {
				configurationMessage("INFORMATION: The proxy will authorize only "
						+ maxServerTransactions + " server transactions");
				configuration.maxServerTransactions = maxServerTransactions
						.trim();
			}

			String threadPoolSize = attrs.getValue("thread_pool_size");
			if (threadPoolSize != null && !threadPoolSize.trim().equals("")) {
				configurationMessage("INFORMATION: The thread pool size is set to "
						+ threadPoolSize);
				configuration.threadPoolSize = threadPoolSize.trim();
			}

		}

		if (element.compareToIgnoreCase("LISTENING_POINT") == 0) {
			String stackPort = attrs.getValue("port");
			if (stackPort == null || stackPort.trim().equals("")) {
				configurationMessage("ERROR: the port of the stack is not set");

			} else {
				String stackTransport = attrs.getValue("transport");
				if (stackTransport == null || stackTransport.trim().equals("")) {
					configurationMessage("ERROR: the transport is not set");

				} else {
					configurationMessage("LISTENING_POINT port = " + stackPort);
					configurationMessage("LISTENING_POINT transport = "
							+ stackTransport);
					configuration.addListeningPoint(stackPort, stackTransport);
				}
			}
		}

		if (element.compareToIgnoreCase("DOMAIN") == 0) {
			String stackDomain = attrs.getValue("domain");
			if (stackDomain != null && !stackDomain.trim().equals("")) {
				configurationMessage("INFORMATION: One domain to take care of is: "
						+ stackDomain);
				configuration.domainList.addElement(stackDomain.trim());
			}
		}

		if (element.compareToIgnoreCase("REGISTER_TO_PROXY") == 0) {
			String hostName = attrs.getValue("host_name");
			Domain domain = new Domain();
			if (hostName != null && !hostName.trim().equals("")) {

				domain.setHostName(hostName);
				String hostPort = attrs.getValue("host_port");
				if (hostPort != null && !hostPort.trim().equals("")) {
					domain.setHostPort(hostPort);
					configurationMessage("INFORMATION: One proxy to register with: "
							+ hostName + ":" + hostPort);
				} else
					configurationMessage("INFORMATION: One proxy to register with: "
							+ hostName);

				String from = attrs.getValue("from");
				if (from != null && !from.trim().equals("")) {
					domain.setFrom(from);
				}

				configuration.proxyToRegisterWithList.addElement(domain);
			}
		}

		if (element.compareToIgnoreCase("REGISTRAR") == 0) {
			String rfc2543Compatible = attrs.getValue("rfc2543_compatible");
			if (rfc2543Compatible != null
					&& "true".equalsIgnoreCase(rfc2543Compatible.trim())) {
				configuration.rfc2543Compatible = true;
			}
			String exportRegistry = attrs.getValue("export_registrations");
			if (exportRegistry != null && !exportRegistry.trim().equals("")) {
				try {
					Boolean b = Boolean.valueOf(exportRegistry.trim());
					if (b.booleanValue()) {

						configurationMessage("INFORMATION: the registrations will be exported");
						configuration.exportRegistry = true;
						String registryPort = attrs.getValue("port");
						if (registryPort == null) {

							configurationMessage("WARNING: The registry port is not set; "
									+ "1099 is used by default");

							configuration.registryPort = "1099";
						} else {

							configurationMessage("INFORMATION: The registry port is: "
									+ registryPort);
							configuration.registryPort = registryPort;
						}
					} else {

						configurationMessage("INFORMATION: the registrations will not be exported");
						configuration.exportRegistry = false;
					}
				} catch (Exception e) {

					configurationMessage("INFORMATION: the registrations will not be exported");
					configuration.exportRegistry = false;
				}
			}
		}

		if (element.compareToIgnoreCase("PRESENCE_SERVER") == 0) {
			String enablePresenceServerString = attrs.getValue("enable");
			if (enablePresenceServerString == null) {
				configuration.enablePresenceServer = false;
				configurationMessage("WARNING: The presence server feature is disabled");
			} else {
				try {
					Boolean b = Boolean.valueOf(enablePresenceServerString
							.trim());
					if (b.booleanValue()) {
						configuration.enablePresenceServer = true;
						configurationMessage("INFORMATION: The presence server feature is enabled");
					} else {
						configuration.enablePresenceServer = false;
						configurationMessage("WARNING: The presence server feature is disabled");
					}
				} catch (Exception e) {
					configuration.enablePresenceServer = false;
					configurationMessage("WARNING: The presence server feature is disabled");
				}
			}
		}

		if (element.compareToIgnoreCase("AUTHENTICATION") == 0) {
			String enableAuthenticationString = attrs.getValue("enable");
			if (enableAuthenticationString == null) {
				configuration.enableAuthentication = false;
				configurationMessage("WARNING: Authentication support is disabled");
			} else {
				try {
					Boolean b = Boolean.valueOf(enableAuthenticationString
							.trim());
					if (b.booleanValue()) {
						configuration.enableAuthentication = true;
						configurationMessage("INFORMATION: Authentication feature is enabled");

					} else {
						configuration.enableAuthentication = false;
						configurationMessage("WARNING: The authentication feature is disabled");
					}
					String method = attrs.getValue("method");
					if (method == null) {
						configurationMessage("WARNING: The Authentication method is not set");
					} else {
						configuration.method = method.trim();
					}
					String classFile = attrs.getValue("class_file");
					if (classFile == null) {
						configurationMessage("WARNING: The class_file parameter is not set"
								+ " for the authentication");
					} else {
						configuration.classFile = classFile.trim();
					}
					String passwordsFile = attrs.getValue("passwords_file");
					if (passwordsFile == null) {
						configurationMessage("WARNING: The passwords file is not set"