Added compression support. JM-333

git-svn-id: http://svn.igniterealtime.org/svn/repos/messenger/trunk@3174 b35dd754-fafc-0310-a699-88a17e54d16e

src/java/org/jivesoftware/messenger/Connection.java

 /**
- * $RCSfile$
+ * $RCSfile: Connection.java,v $
  * $Revision$
  * $Date$
  *
@@ -13,6 +13,7 @@ package org.jivesoftware.messenger;
 
 import org.xmpp.packet.Packet;
 import org.jivesoftware.messenger.auth.UnauthorizedException;
+import org.jivesoftware.messenger.net.SocketConnection;
 
 import java.net.InetAddress;
 import java.net.UnknownHostException;
@@ -176,4 +177,88 @@ public interface Connection {
      * @return the language code for the connection.
      */
     public String getLanguage();
+
+    /**
+     * Returns true if the connection is using compression.
+     *
+     * @return true if the connection is using compression.
+     */
+    boolean isCompressed();
+
+    /**
+     * Returns whether compression is optional or is disabled.
+     *
+     * @return whether compression is optional or is disabled.
+     */
+    CompressionPolicy getCompressionPolicy();
+
+    /**
+     * Sets whether compression is enabled or is disabled.
+     *
+     * @param compressionPolicy whether Compression is enabled or is disabled.
+     */
+    void setCompressionPolicy(CompressionPolicy compressionPolicy);
+
+    /**
+     * Returns whether TLS is mandatory, optional or is disabled. When TLS is mandatory clients
+     * are required to secure their connections or otherwise their connections will be closed.
+     * On the other hand, when TLS is disabled clients are not allowed to secure their connections
+     * using TLS. Their connections will be closed if they try to secure the connection. in this
+     * last case.
+     *
+     * @return whether TLS is mandatory, optional or is disabled.
+     */
+    TLSPolicy getTlsPolicy();
+
+    /**
+     * Sets whether TLS is mandatory, optional or is disabled. When TLS is mandatory clients
+     * are required to secure their connections or otherwise their connections will be closed.
+     * On the other hand, when TLS is disabled clients are not allowed to secure their connections
+     * using TLS. Their connections will be closed if they try to secure the connection. in this
+     * last case.
+     *
+     * @param tlsPolicy whether TLS is mandatory, optional or is disabled.
+     */
+    void setTlsPolicy(TLSPolicy tlsPolicy);
+
+    /**
+     * Enumeration of possible compression policies required to interact with the server.
+     */
+    enum CompressionPolicy {
+
+        /**
+         * compression is optional to interact with the server.
+         */
+        optional,
+
+        /**
+         * compression is not available. Entities that request a compression negotiation
+         * will get a stream error and their connections will be closed.
+         */
+        disabled;
+    }
+
+    /**
+     * Enumeration of possible TLS policies required to interact with the server.
+     */
+    enum TLSPolicy {
+
+        /**
+         * TLS is required to interact with the server. Entities that do not secure their
+         * connections using TLS will get a stream error and their connections will be closed.
+         */
+        required,
+
+        /**
+         * TLS is optional to interact with the server. Entities may or may not secure their
+         * connections using TLS.
+         */
+        optional,
+
+        /**
+         * TLS is not available. Entities that request a TLS negotiation will get a stream
+         * error and their connections will be closed.
+         */
+        disabled;
+    }
 }

src/java/org/jivesoftware/messenger/Session.java

@@ -260,6 +260,14 @@ public abstract class Session implements RoutableChannelHandler {
         sessionData.remove(key);
     }
 
+    /**
+     * Returns a text with the available stream features. Each subclass may return different
+     * values depending whether the session has been authenticated or not.
+     *
+     * @return a text with the available stream features or <tt>null</tt> to add nothing.
+     */
+    public abstract String getAvailableStreamFeatures();
+
     public String toString() {
         return super.toString() + " status: " + status + " address: " + address + " id: " + streamID;
     }

src/java/org/jivesoftware/messenger/component/ComponentSession.java

@@ -199,6 +199,11 @@ public class ComponentSession extends Session {
         super(serverName, conn, id);
     }
 
+    public String getAvailableStreamFeatures() {
+        // Nothing special to add
+        return null;
+    }
+
     public void process(Packet packet) throws PacketException {
         // Since ComponentSessions are not being stored in the RoutingTable this messages is very
         // unlikely to be sent

src/java/org/jivesoftware/messenger/net/ClientSocketReader.java

@@ -14,7 +14,6 @@ package org.jivesoftware.messenger.net;
 import org.dom4j.Element;
 import org.jivesoftware.messenger.ClientSession;
 import org.jivesoftware.messenger.PacketRouter;
-import org.jivesoftware.messenger.XMPPServer;
 import org.jivesoftware.messenger.auth.UnauthorizedException;
 import org.jivesoftware.util.JiveGlobals;
 import org.xmlpull.v1.XmlPullParserException;
@@ -91,26 +90,4 @@ public class ClientSocketReader extends SocketReader {
     boolean validateHost() {
         return JiveGlobals.getBooleanProperty("xmpp.client.validate.host",false);
     }
-
-    protected String getAvailableStreamFeatures() {
-        StringBuilder sb = new StringBuilder(110);
-        // TODO Create and use #hasSASLAuthentication
-        if (((ClientSession)session).getAuthToken() == null) {
-            // Advertise that the server supports Non-SASL Authentication
-            if (XMPPServer.getInstance().getIQAuthHandler().isAllowAnonymous()) {
-                sb.append("<auth xmlns=\"http://jabber.org/features/iq-auth\"/>");
-            }
-            // Advertise that the server supports In-Band Registration
-            if (XMPPServer.getInstance().getIQRegisterHandler().isInbandRegEnabled()) {
-                sb.append("<register xmlns=\"http://jabber.org/features/iq-register\"/>");
-            }
-        }
-        else {
-            // If the session has been authenticated then offer resource binding
-            // and session establishment
-            sb.append("<bind xmlns=\"urn:ietf:params:xml:ns:xmpp-bind\"/>");
-            sb.append("<session xmlns=\"urn:ietf:params:xml:ns:xmpp-session\"/>");
-        }
-        return sb.toString();
-    }
 }

src/java/org/jivesoftware/messenger/net/ComponentSocketReader.java

@@ -61,9 +61,4 @@ public class ComponentSocketReader extends SocketReader {
     boolean validateHost() {
         return false;
     }
-
-    String getAvailableStreamFeatures() {
-        // Nothing special to add
-        return null;
-    }
 }

src/java/org/jivesoftware/messenger/net/ServerSocketReader.java

@@ -218,9 +218,4 @@ public class ServerSocketReader extends SocketReader {
     boolean validateHost() {
         return true;
     }
-
-    String getAvailableStreamFeatures() {
-        // Nothing special to add
-        return null;
-    }
 }

src/java/org/jivesoftware/messenger/net/SocketConnection.java

@@ -31,6 +31,7 @@ import java.util.Map;
 import java.util.Collection;
 import java.util.Date;
 import java.util.concurrent.ConcurrentHashMap;
+import java.util.zip.*;
 
 /**
  * An object to track the state of a XMPP client-server session.
@@ -59,6 +60,7 @@ public class SocketConnection implements Connection {
 
     private Session session;
     private boolean secure;
+	private boolean compressed;
     private org.jivesoftware.util.XMLWriter xmlSerializer;
     private boolean flashClient = false;
     private int majorVersion = 1;
@@ -73,6 +75,11 @@ public class SocketConnection implements Connection {
      */
     private TLSPolicy tlsPolicy = TLSPolicy.optional;
 
+	/**
+	 * Compression policy currently in use for this connection.
+	 */
+	private CompressionPolicy compressionPolicy = CompressionPolicy.disabled;
+
     public static Collection<SocketConnection> getInstances() {
         return instances.keySet();
     }
@@ -86,8 +93,7 @@ public class SocketConnection implements Connection {
      * @throws NullPointerException if the socket is null.
      */
     public SocketConnection(PacketDeliverer deliverer, Socket socket, boolean isSecure)
-            throws IOException
-    {
+            throws IOException {
         if (socket == null) {
             throw new NullPointerException("Socket channel must be non-null");
         }
@@ -127,6 +133,26 @@ public class SocketConnection implements Connection {
         }
     }
 
+    /**
+     * Start using compression for this connection. Compression will only be available after TLS
+     * has been negotiated. This means that a connection can never be using compression before
+     * TLS. However, it is possible to use compression without TLS.
+     *
+     * @throws IOException if an error occured while starting compression.
+     */
+    public void startCompression() throws IOException {
+        compressed = true;
+
+        if (tlsStreamHandler == null) {
+            writer = new BufferedWriter(
+                    new OutputStreamWriter(new ZipOutputStream(socket.getOutputStream()), CHARSET));
+        }
+        else {
+            writer = new BufferedWriter(new OutputStreamWriter(
+                    new ZipOutputStream(tlsStreamHandler.getOutputStream()), CHARSET));
+        }
+    }
+
     public boolean validate() {
         if (isClosed()) {
             return false;
@@ -188,32 +214,26 @@ public class SocketConnection implements Connection {
         return secure;
     }
 
-    /**
-     * Returns whether TLS is mandatory, optional or is disabled. When TLS is mandatory clients
-     * are required to secure their connections or otherwise their connections will be closed.
-     * On the other hand, when TLS is disabled clients are not allowed to secure their connections
-     * using TLS. Their connections will be closed if they try to secure the connection. in this
-     * last case.
-     *
-     * @return whether TLS is mandatory, optional or is disabled.
-     */
+    public boolean isCompressed() {
+        return compressed;
+    }
+
     public TLSPolicy getTlsPolicy() {
         return tlsPolicy;
     }
 
-    /**
-     * Sets whether TLS is mandatory, optional or is disabled. When TLS is mandatory clients
-     * are required to secure their connections or otherwise their connections will be closed.
-     * On the other hand, when TLS is disabled clients are not allowed to secure their connections
-     * using TLS. Their connections will be closed if they try to secure the connection. in this
-     * last case.
-     *
-     * @param tlsPolicy whether TLS is mandatory, optional or is disabled.
-     */
     public void setTlsPolicy(TLSPolicy tlsPolicy) {
         this.tlsPolicy = tlsPolicy;
     }
 
+    public CompressionPolicy getCompressionPolicy() {
+        return compressionPolicy;
+    }
+
+    public void setCompressionPolicy(CompressionPolicy compressionPolicy) {
+        this.compressionPolicy = compressionPolicy;
+    }
+
     public int getMajorXMPPVersion() {
         return majorVersion;
     }
@@ -334,7 +354,7 @@ public class SocketConnection implements Connection {
      * sending data over the socket has taken a long time and we need to close the socket, discard
      * the connection and its session.
      */
-    void forceClose() {
+    private void forceClose() {
         if (session != null) {
             // Set that the session is closed. This will prevent threads from trying to
             // deliver packets to this session thus preventing future locks.
@@ -439,7 +459,12 @@ public class SocketConnection implements Connection {
     private void notifyCloseListeners() {
         synchronized (listeners) {
             for (ConnectionCloseListener listener : listeners.keySet()) {
-                listener.onConnectionClose(listeners.get(listener));
+                try {
+                    listener.onConnectionClose(listeners.get(listener));
+                }
+                catch (Exception e) {
+                    Log.error("Error notifying listener: " + listener, e);
+                }
             }
         }
     }
@@ -448,27 +473,4 @@ public class SocketConnection implements Connection {
         return super.toString() + " socket: " + socket + " session: " + session;
     }
 
-    /**
-     * Enumeration of possible TLS policies required to interact with the server.
-     */
-    public enum TLSPolicy {
-
-        /**
-         * TLS is required to interact with the server. Entities that do not secure their
-         * connections using TLS will get a stream error and their connections will be closed.
-         */
-        required,
-
-        /**
-         * TLS is optional to interact with the server. Entities may or may not secure their
-         * connections using TLS.
-         */
-        optional,
-
-        /**
-         * TLS is not available. Entities that request a TLS negotiation will get a stream
-         * error and their connections will be closed.
-         */
-        disabled;
-    }
 }
\ No newline at end of file

src/java/org/jivesoftware/messenger/net/SocketReader.java

@@ -11,8 +11,8 @@
 
 package org.jivesoftware.messenger.net;
 
-import org.dom4j.Element;
 import org.dom4j.DocumentException;
+import org.dom4j.Element;
 import org.dom4j.io.XPPPacketReader;
 import org.jivesoftware.messenger.*;
 import org.jivesoftware.messenger.auth.UnauthorizedException;
@@ -33,6 +33,7 @@ import java.io.InputStreamReader;
 import java.net.Socket;
 import java.net.SocketException;
 import java.nio.channels.AsynchronousCloseException;
+import java.util.zip.ZipInputStream;
 
 /**
  * A SocketReader creates the appropriate {@link Session} based on the defined namespace in the
@@ -260,7 +261,6 @@ public abstract class SocketReader implements Runnable {
                     open = false;
                     session = null;
                 }
-                continue;
             }
             else if ("auth".equals(tag)) {
                 // User is trying to authenticate using SASL
@@ -273,9 +273,22 @@ public abstract class SocketReader implements Runnable {
                     open = false;
                     session = null;
                 }
-                continue;
             }
-            else {
+			else if ("compress".equals(tag)) 
+			{
+                // Client is trying to initiate compression
+                if (compressClient(doc)) {
+                    // Compression was successful so open a new stream and offer
+                    // resource binding and session establishment (to client sessions only)
+                    compressionSuccessful();
+                }
+                else {
+                    open = false;
+                    session = null;
+                }
+			}
+            else 
+			{
                 if (!processUnknowPacket(doc)) {
                     Log.warn(LocaleUtils.getLocalizedString("admin.error.packet.tag") +
                             doc.asXML());
@@ -288,7 +301,7 @@ public abstract class SocketReader implements Runnable {
     private boolean authenticateClient(Element doc) throws DocumentException, IOException,
             XmlPullParserException {
         // Ensure that connection was secured if TLS was required
-        if (connection.getTlsPolicy() == SocketConnection.TLSPolicy.required &&
+        if (connection.getTlsPolicy() == Connection.TLSPolicy.required &&
                 !connection.isSecure()) {
             closeNeverSecuredConnection();
             return false;
@@ -297,6 +310,59 @@ public abstract class SocketReader implements Runnable {
         return saslAuth.doHandshake(doc);
     }
 
+    /**
+     * Start using compression but first check if the connection can and should use compression.
+     * The connection will be closed if the requested method is not supported, if the connection
+     * is already using compression or if client requested to use compression but this feature
+     * is disabled.
+     *
+     * @param doc the element sent by the client requesting compression. Compression method is
+     *        included.
+     * @return true if it was possible to use compression.
+     * @throws IOException if an error occurs while starting using compression.
+     */
+    private boolean compressClient(Element doc) throws IOException {
+        String error = null;
+        if (connection.getCompressionPolicy() == Connection.CompressionPolicy.disabled) {
+            // Client requested compression but this feature is disabled
+            error = "<failure xmlns='http://jabber.org/protocol/compress'><setup-failed/></failure>";
+            // Log a warning so that admins can track this case from the server side
+            Log.warn("Client requested compression while compression is disabled. Closing " +
+                    "connection : " + connection);
+        }
+        else if (connection.isCompressed()) {
+            // Client requested compression but connection is already compressed
+            error = "<failure xmlns='http://jabber.org/protocol/compress'><setup-failed/></failure>";
+            // Log a warning so that admins can track this case from the server side
+            Log.warn("Client requested compression and connection is already compressed. Closing " +
+                    "connection : " + connection);
+        }
+        else {
+            // Check that the requested method is supported
+            String method = doc.elementText("method");
+            if (!"zlib".equals(method)) {
+                error = "<failure xmlns='http://jabber.org/protocol/compress'><unsupported-method/></failure>";
+                // Log a warning so that admins can track this case from the server side
+                Log.warn("Requested compression method is not supported: " + method +
+                        ". Closing connection : " + connection);
+            }
+        }
+
+        if (error != null) {
+            // Deliver stanza
+            connection.deliverRawText(error);
+            // Close the underlying connection
+            connection.close();
+            return false;
+        }
+        else {
+            // Start using compression
+            connection.startCompression();
+            return true;
+        }
+
+    }
+
     /**
      * Process the received IQ packet. Registered
      * {@link org.jivesoftware.messenger.interceptor.PacketInterceptor} will be invoked before
@@ -310,7 +376,7 @@ public abstract class SocketReader implements Runnable {
      */
     protected void processIQ(IQ packet) throws UnauthorizedException {
         // Ensure that connection was secured if TLS was required
-        if (connection.getTlsPolicy() == SocketConnection.TLSPolicy.required &&
+        if (connection.getTlsPolicy() == Connection.TLSPolicy.required &&
                 !connection.isSecure()) {
             closeNeverSecuredConnection();
             return;
@@ -359,7 +425,7 @@ public abstract class SocketReader implements Runnable {
      */
     protected void processPresence(Presence packet) throws UnauthorizedException {
         // Ensure that connection was secured if TLS was required
-        if (connection.getTlsPolicy() == SocketConnection.TLSPolicy.required &&
+        if (connection.getTlsPolicy() == Connection.TLSPolicy.required &&
                 !connection.isSecure()) {
             closeNeverSecuredConnection();
             return;
@@ -407,7 +473,7 @@ public abstract class SocketReader implements Runnable {
      */
     protected void processMessage(Message packet) throws UnauthorizedException {
         // Ensure that connection was secured if TLS was required
-        if (connection.getTlsPolicy() == SocketConnection.TLSPolicy.required &&
+        if (connection.getTlsPolicy() == Connection.TLSPolicy.required &&
                 !connection.isSecure()) {
             closeNeverSecuredConnection();
             return;
@@ -576,7 +642,7 @@ public abstract class SocketReader implements Runnable {
      * @throws XmlPullParserException if an error occures while parsing.
      */
     private boolean negotiateTLS() throws IOException, XmlPullParserException {
-        if (connection.getTlsPolicy() == SocketConnection.TLSPolicy.disabled) {
+        if (connection.getTlsPolicy() == Connection.TLSPolicy.disabled) {
             // Set the not_authorized error
             StreamError error = new StreamError(StreamError.Condition.not_authorized);
             // Deliver stanza
@@ -617,13 +683,13 @@ public abstract class SocketReader implements Runnable {
      */
     private void tlsNegotiated() {
         // Offer stream features including SASL Mechanisms
-        StringBuilder sb = new StringBuilder(340);
+        StringBuilder sb = new StringBuilder(620);
         sb.append(geStreamHeader());
         sb.append("<stream:features>");
         // Include available SASL Mechanisms
         sb.append(SASLAuthentication.getSASLMechanisms(session));
         // Include specific features such as auth and register for client sessions
-        String specificFeatures = getAvailableStreamFeatures();
+        String specificFeatures = session.getAvailableStreamFeatures();
         if (specificFeatures != null) {
             sb.append(specificFeatures);
         }
@@ -638,43 +704,84 @@ public abstract class SocketReader implements Runnable {
      * to servers or external components)
      */
     private void saslSuccessful() throws XmlPullParserException, IOException {
-        StringBuilder sb = new StringBuilder(145);
+		XmlPullParser xpp = reader.getXPPParser();
+		// Reset the parser since a new stream header has been sent from the client
+		if (connection.getTLSStreamHandler() == null) 
+		{
+			xpp.setInput(new InputStreamReader(socket.getInputStream(), CHARSET));
+		}
+		else 
+		{
+			xpp.setInput(new InputStreamReader(connection.getTLSStreamHandler().getInputStream(),
+				CHARSET));
+		}
+
+		// Skip the opening stream sent by the client
+		for (int eventType = xpp.getEventType(); eventType != XmlPullParser.START_TAG;) 
+		{
+			eventType = xpp.next();
+		}
+
+        StringBuilder sb = new StringBuilder(420);
         sb.append(geStreamHeader());
         sb.append("<stream:features>");
 
         // Include specific features such as resource binding and session establishment
         // for client sessions
-        String specificFeatures = getAvailableStreamFeatures();
+        String specificFeatures = session.getAvailableStreamFeatures();
         if (specificFeatures != null) {
             sb.append(specificFeatures);
         }
         sb.append("</stream:features>");
         connection.deliverRawText(sb.toString());
+    }
 
+	/**
+	 * After compression was successful we should open a new stream and offer
+	 * new stream features such as resource binding and session establishment. Notice that
+	 * resource binding and session establishment should only be offered to clients (i.e. not
+	 * to servers or external components)
+	 */
+	private void compressionSuccessful() throws XmlPullParserException, IOException
+	{
+		connection.deliverRawText("<compressed xmlns='http://jabber.org/protocol/compress'/>");
 
         XmlPullParser xpp = reader.getXPPParser();
         // Reset the parser since a new stream header has been sent from the client
-        if (connection.getTLSStreamHandler() == null) {
-            xpp.setInput(new InputStreamReader(socket.getInputStream(), CHARSET));
+		if (connection.getTLSStreamHandler() == null)
+		{
+			xpp.setInput(new InputStreamReader(new ZipInputStream (socket.getInputStream()), CHARSET));
         }
-        else {
-            xpp.setInput(new InputStreamReader(connection.getTLSStreamHandler().getInputStream(),
+		else
+		{
+			xpp.setInput(new InputStreamReader(new ZipInputStream (connection.getTLSStreamHandler().getInputStream()),
                     CHARSET));
         }
 
         // Skip the opening stream sent by the client
-        for (int eventType = xpp.getEventType(); eventType != XmlPullParser.START_TAG;) {
+		for (int eventType = xpp.getEventType(); eventType != XmlPullParser.START_TAG;)
+		{
             eventType = xpp.next();
         }
-    }
 
-    /**
-     * Returns a text with the available stream features. Each subclass may return different
-     * values depending whether the session has been authenticated or not.
-     *
-     * @return a text with the available stream features or <tt>null</tt> to add nothing.
-     */
-    abstract String getAvailableStreamFeatures();
+		StringBuilder sb = new StringBuilder(340);
+		sb.append(geStreamHeader());
+		sb.append("<stream:features>");
+        // Include SASL mechanisms only if client has not been authenticated
+        if (session.getStatus() != Session.STATUS_AUTHENTICATED) {
+            // Include available SASL Mechanisms
+            sb.append(SASLAuthentication.getSASLMechanisms(session));
+        }
+		// Include specific features such as resource binding and session establishment
+		// for client sessions
+		String specificFeatures = session.getAvailableStreamFeatures();
+		if (specificFeatures != null)
+		{
+			sb.append(specificFeatures);
+		}
+		sb.append("</stream:features>");
+		connection.deliverRawText(sb.toString());
+    }
 
     /**
      * Returns the stream namespace. (E.g. jabber:client, jabber:server, etc.).

src/java/org/jivesoftware/messenger/server/IncomingServerSession.java

@@ -280,4 +280,9 @@ public class IncomingServerSession extends Session {
     public void verifyReceivedKey(Element doc) {
         ServerDialback.verifyReceivedKey(doc, getConnection());
     }
+
+    public String getAvailableStreamFeatures() {
+        // Nothing special to add
+        return null;
+    }
 }

src/java/org/jivesoftware/messenger/server/OutgoingServerSession.java

@@ -503,4 +503,8 @@ public class OutgoingServerSession extends Session {
         }
     }
 
+    public String getAvailableStreamFeatures() {
+        // Nothing special to add
+        return null;
+    }
 }

src/web/ssl-settings.jsp

@@ -21,6 +21,7 @@
 <%@ page import="org.jivesoftware.messenger.net.SocketConnection"%>
 <%@ page import="org.jivesoftware.messenger.XMPPServer"%>
 <%@ page import="org.jivesoftware.messenger.ConnectionManager"%>
+<%@ page import="org.jivesoftware.messenger.Connection"%>
 
 <%@ taglib uri="http://java.sun.com/jstl/core_rt" prefix="c" %>
 <%@ taglib uri="http://java.sun.com/jstl/fmt_rt" prefix="fmt" %>
@@ -49,7 +50,7 @@
 
             // Enable 5222 port and make TLS required
             XMPPServer.getInstance().getConnectionManager().enableClientListener(true);
-            ClientSession.setTLSPolicy(SocketConnection.TLSPolicy.required);
+            ClientSession.setTLSPolicy(Connection.TLSPolicy.required);
             // Enable 5223 port (old SSL port)
             XMPPServer.getInstance().getConnectionManager().enableClientSSLListener(true);
         }
@@ -58,7 +59,7 @@
 
             // Enable 5222 port and make TLS optional
             XMPPServer.getInstance().getConnectionManager().enableClientListener(true);
-            ClientSession.setTLSPolicy(SocketConnection.TLSPolicy.optional);
+            ClientSession.setTLSPolicy(Connection.TLSPolicy.optional);
             // Enable 5223 port (old SSL port)
             XMPPServer.getInstance().getConnectionManager().enableClientSSLListener(true);
         }
@@ -71,13 +72,13 @@
             // Enable port 5222 and configure TLS policy
             XMPPServer.getInstance().getConnectionManager().enableClientListener(true);
             if ("notavailable".equals(tls)) {
-                ClientSession.setTLSPolicy(SocketConnection.TLSPolicy.disabled);
+                ClientSession.setTLSPolicy(Connection.TLSPolicy.disabled);
             }
             else if ("optional".equals(tls)) {
-                ClientSession.setTLSPolicy(SocketConnection.TLSPolicy.optional);
+                ClientSession.setTLSPolicy(Connection.TLSPolicy.optional);
             }
             else {
-                ClientSession.setTLSPolicy(SocketConnection.TLSPolicy.required);
+                ClientSession.setTLSPolicy(Connection.TLSPolicy.required);
             }
         }
         success = true;
@@ -86,12 +87,12 @@
     // Set page vars
     ConnectionManager connectionManager = XMPPServer.getInstance().getConnectionManager();
     if (connectionManager.isClientListenerEnabled() && connectionManager.isClientSSLListenerEnabled()) {
-        if (SocketConnection.TLSPolicy.required.equals(ClientSession.getTLSPolicy())) {
+        if (Connection.TLSPolicy.required.equals(ClientSession.getTLSPolicy())) {
             clientSecurityRequired = "req";
             ssl = "available";
             tls = "required";
         }
-        else if (SocketConnection.TLSPolicy.optional.equals(ClientSession.getTLSPolicy())) {
+        else if (Connection.TLSPolicy.optional.equals(ClientSession.getTLSPolicy())) {
             clientSecurityRequired = "notreq";
             ssl = "available";
             tls = "optional";
@@ -105,7 +106,7 @@
     else {
         clientSecurityRequired = "custom";
         ssl = connectionManager.isClientSSLListenerEnabled() ? "available" : "notavailable";
-        tls = SocketConnection.TLSPolicy.disabled.equals(ClientSession.getTLSPolicy()) ? "notavailable" : ClientSession.getTLSPolicy().toString();
+        tls = Connection.TLSPolicy.disabled.equals(ClientSession.getTLSPolicy()) ? "notavailable" : ClientSession.getTLSPolicy().toString();
     }
 
     if (install) {