Added XEP-199 aka. "XMPP Ping" support to smack. Fixes SMACK-388.

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

build/resources/META-INF/smack-config.xml

@@ -31,4 +31,7 @@
     <!-- Port of the local Socks5 proxy -->
     <packetCollectorSize>10000</packetCollectorSize>
     
+    <!-- Default interval in which the Ping Manager sends ping request to the server (30 minutes) -->
+    <defaultPingInterval>1800000</defaultPingInterval>
+
 </smack>

build/resources/META-INF/smack.providers

@@ -237,6 +237,13 @@
         <className>org.jivesoftware.smackx.provider.AdHocCommandDataProvider</className>
     </iqProvider>
 
+    <!-- Ping (XEP-199) Manager -->
+    <iqProvider>
+        <elementName>ping</elementName>
+        <namespace>urn:xmpp:ping</namespace>
+        <className>org.jivesoftware.smackx.provider.PingProvider</className>
+    </iqProvider>
+
     <extensionProvider>
         <elementName>bad-action</elementName>
         <namespace>http://jabber.org/protocol/commands</namespace>

source/org/jivesoftware/smack/SmackConfiguration.java

@@ -20,12 +20,16 @@
 
 package org.jivesoftware.smack;
 
-import org.xmlpull.mxp1.MXParser;
-import org.xmlpull.v1.XmlPullParser;
-
 import java.io.InputStream;
 import java.net.URL;
-import java.util.*;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Enumeration;
+import java.util.List;
+import java.util.Vector;
+
+import org.xmlpull.mxp1.MXParser;
+import org.xmlpull.v1.XmlPullParser;
 
 /**
  * Represents the configuration of Smack. The configuration is used for:
@@ -54,6 +58,8 @@ public final class SmackConfiguration {
     private static int localSocks5ProxyPort = 7777;
     private static int packetCollectorSize = 5000;
 
+    private static int defaultPingInterval = 1800000; // 30 min (30*60*1000)
+
     private SmackConfiguration() {
     }
 
@@ -103,6 +109,9 @@ public final class SmackConfiguration {
                                 else if (parser.getName().equals("packetCollectorSize")) {
                                     packetCollectorSize = parseIntProperty(parser, packetCollectorSize);
                                 }
+ else if (parser.getName().equals("defaultPingInterval")) {
+                                    defaultPingInterval = parseIntProperty(parser, defaultPingInterval);
+                                }
                             }
                             eventType = parser.next();
                         }
@@ -299,6 +308,14 @@ public final class SmackConfiguration {
         SmackConfiguration.localSocks5ProxyPort = localSocks5ProxyPort;
     }
 
+    public static int getDefaultPingInterval() {
+        return defaultPingInterval;
+    }
+
+    public static void setDefaultPingInterval(int defaultPingInterval) {
+        SmackConfiguration.defaultPingInterval = defaultPingInterval;
+    }
+
     private static void parseClassToLoad(XmlPullParser parser) throws Exception {
         String className = parser.nextText();
         // Attempt to load the class so that the class can get initialized

source/org/jivesoftware/smackx/packet/Ping.java

@@ -0,0 +1,38 @@
+/**
+ * Copyright 2012 Florian Schmaus
+ *
+ * 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.smackx.packet;
+
+import org.jivesoftware.smack.packet.IQ;
+import org.jivesoftware.smackx.ping.PingManager;
+
+public class Ping extends IQ {
+    
+    public Ping() {
+    }
+    
+    public Ping(String from, String to) {
+        setTo(to);
+        setFrom(from);
+        setType(IQ.Type.GET);
+        setPacketID(getPacketID());
+    }
+    
+    public String getChildElementXML() {
+        return "<" + PingManager.ELEMENT + " xmlns=\'" + PingManager.NAMESPACE + "\' />";
+    }
+
+}

source/org/jivesoftware/smackx/packet/Pong.java

@@ -0,0 +1,45 @@
+/**
+ * Copyright 2012 Florian Schmaus
+ *
+ * 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.smackx.packet;
+
+import org.jivesoftware.smack.packet.IQ;
+
+public class Pong extends IQ {
+    
+    /**
+     * Composes a Pong packet from a received ping packet. This basically swaps
+     * the 'from' and 'to' attributes. And sets the IQ type to result.
+     * 
+     * @param ping
+     */
+    public Pong(Ping ping) {
+        setType(IQ.Type.RESULT);
+        setFrom(ping.getTo());
+        setTo(ping.getFrom());
+        setPacketID(ping.getPacketID());
+    }
+    
+    /*
+     * Returns the child element of the Pong reply, which is non-existent. This
+     * is why we return 'null' here. See e.g. Example 11 from
+     * http://xmpp.org/extensions/xep-0199.html#e2e
+     */
+    public String getChildElementXML() {
+        return null;
+    }
+
+}

source/org/jivesoftware/smackx/ping/PingFailedListener.java

@@ -0,0 +1,21 @@
+/**
+ * Copyright 2012 Florian Schmaus
+ *
+ * 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.smackx.ping;
+
+public interface PingFailedListener {
+    void pingFailed();
+}

source/org/jivesoftware/smackx/ping/PingManager.java

@@ -0,0 +1,340 @@
+/**
+ * Copyright 2012 Florian Schmaus
+ *
+ * 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.smackx.ping;
+
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+import java.util.WeakHashMap;
+
+import org.jivesoftware.smack.AbstractConnectionListener;
+import org.jivesoftware.smack.Connection;
+import org.jivesoftware.smack.ConnectionCreationListener;
+import org.jivesoftware.smack.PacketCollector;
+import org.jivesoftware.smack.PacketListener;
+import org.jivesoftware.smack.SmackConfiguration;
+import org.jivesoftware.smack.XMPPException;
+import org.jivesoftware.smack.filter.PacketFilter;
+import org.jivesoftware.smack.filter.PacketIDFilter;
+import org.jivesoftware.smack.filter.PacketTypeFilter;
+import org.jivesoftware.smack.packet.IQ;
+import org.jivesoftware.smack.packet.Packet;
+import org.jivesoftware.smack.provider.ProviderManager;
+import org.jivesoftware.smackx.ServiceDiscoveryManager;
+import org.jivesoftware.smackx.packet.DiscoverInfo;
+import org.jivesoftware.smackx.packet.Ping;
+import org.jivesoftware.smackx.packet.Pong;
+import org.jivesoftware.smackx.provider.PingProvider;
+
+/**
+ * Implements the XMPP Ping as defined by XEP-0199. This protocol offers an
+ * alternative to the traditional 'white space ping' approach of determining the
+ * availability of an entity. The XMPP Ping protocol allows ping messages to be
+ * send in a more XML-friendly approach, which can be used over more than one
+ * hop in the communication path.
+ * 
+ * @author Florian Schmaus
+ * @see <a href="http://www.xmpp.org/extensions/xep-0199.html">XEP-0199:XMPP
+ *      Ping</a>
+ */
+public class PingManager {
+    
+    public static final String NAMESPACE = "urn:xmpp:ping";
+    public static final String ELEMENT = "ping";
+    
+    private static Map<Connection, PingManager> instances =
+            Collections.synchronizedMap(new WeakHashMap<Connection, PingManager>());
+    
+    static {
+        ProviderManager.getInstance().addIQProvider(ELEMENT, NAMESPACE, new PingProvider());
+        Connection.addConnectionCreationListener(new ConnectionCreationListener() {
+            public void connectionCreated(Connection connection) {
+                new PingManager(connection);
+            }
+        });
+    }
+    
+    private Connection connection;
+    private Thread serverPingThread;
+    private ServerPingTask serverPingTask;
+    private int pingInterval = SmackConfiguration.getDefaultPingInterval();
+    private Set<PingFailedListener> pingFailedListeners = Collections
+            .synchronizedSet(new HashSet<PingFailedListener>());
+    
+    // Ping Flood protection
+    private long pingMinDelta = 100;
+    private long lastPingStamp = 0; // timestamp of the last received ping
+    
+    // Last server pong timestamp if a ping request manually
+    private long lastServerPingStamp = -1;
+    
+    private PingManager(Connection connection) {
+        ServiceDiscoveryManager sdm = ServiceDiscoveryManager.getInstanceFor(connection);
+        sdm.addFeature(NAMESPACE);
+        this.connection = connection;
+        PacketFilter pingPacketFilter = new PacketTypeFilter(Ping.class);
+        connection.addPacketListener(new PingPacketListener(), pingPacketFilter);
+        connection.addConnectionListener(new PingConnectionListener());
+        instances.put(connection, this);
+        maybeStartPingServerTask();
+    }
+    
+    public static PingManager getInstaceFor(Connection connection) {
+        PingManager pingManager = instances.get(connection);
+        
+        if (pingManager == null) {
+            pingManager = new PingManager(connection);
+        }
+        
+        return pingManager;
+    }
+    
+    public void setPingIntervall(int pingIntervall) {
+        this.pingInterval = pingIntervall;
+        if (serverPingTask != null) {
+            serverPingTask.setPingInterval(pingIntervall);
+        }
+    }
+    
+    public int getPingIntervall() {
+        return pingInterval;
+    }
+    
+    public void registerPingFailedListener(PingFailedListener listener) {
+        pingFailedListeners.add(listener);
+    }
+    
+    public void unregisterPingFailedListener(PingFailedListener listener) {
+        pingFailedListeners.remove(listener);
+    }
+    
+    public void disablePingFloodProtection() {
+        setPingMinimumInterval(-1);
+    }
+    
+    public void setPingMinimumInterval(long ms) {
+        this.pingMinDelta = ms;
+    }
+    
+    public long getPingMinimumInterval() {
+        return this.pingMinDelta;
+    }
+    
+    /**
+     * Pings the given jid and returns the IQ response which is either of 
+     * IQ.Type.ERROR or IQ.Type.RESULT. If we are not connected or if there was
+     * no reply, null is returned.
+     * 
+     * You should use isPingSupported(jid) to determine if XMPP Ping is 
+     * supported by the user.
+     * 
+     * @param jid
+     * @param pingTimeout
+     * @return
+     */
+    public IQ ping(String jid, long pingTimeout) {
+        // Make sure we actually connected to the server
+        if (!connection.isAuthenticated())
+            return null;
+        
+        Ping ping = new Ping(connection.getUser(), jid);
+        
+        PacketCollector collector =
+                connection.createPacketCollector(new PacketIDFilter(ping.getPacketID()));
+        
+        connection.sendPacket(ping);
+        
+        IQ result = (IQ) collector.nextResult(pingTimeout);
+        
+        collector.cancel();
+        return result;
+    }
+    
+    /**
+     * Pings the given jid and returns the IQ response with the default
+     * packet reply timeout
+     * 
+     * @param jid
+     * @return
+     */
+    public IQ ping(String jid) {
+        return ping(jid, SmackConfiguration.getPacketReplyTimeout());
+    }
+    
+    /**
+     * Pings the given Entity.
+     * 
+     * Note that XEP-199 shows that if we receive a error response
+     * service-unavailable there is no way to determine if the response was send
+     * by the entity (e.g. a user JID) or from a server in between. This is
+     * intended behavior to avoid presence leaks.
+     * 
+     * Always use isPingSupported(jid) to determine if XMPP Ping is supported
+     * by the entity.
+     * 
+     * @param jid
+     * @return True if a pong was received, otherwise false
+     */
+    public boolean pingEntity(String jid, long pingTimeout) {
+        IQ result = ping(jid, pingTimeout);
+        
+        if (result == null 
+                || result.getType() == IQ.Type.ERROR) {
+            return false;
+        } 
+        return true;
+    }
+    
+    public boolean pingEntity(String jid) {
+        return pingEntity(jid, SmackConfiguration.getPacketReplyTimeout());
+    }
+    
+    /**
+     * Pings the user's server. Will notify the registered 
+     * pingFailedListeners in case of error.
+     * 
+     * If we receive as response, we can be sure that it came from the server.
+     * 
+     * @return true if successful, otherwise false
+     */
+    public boolean pingMyServer(long pingTimeout) {
+        IQ result = ping(connection.getServiceName(), pingTimeout);
+
+        if (result == null) {
+            for (PingFailedListener l : pingFailedListeners) {
+                l.pingFailed();
+            }
+            return false;
+        }
+        lastServerPingStamp = System.currentTimeMillis();
+        return true;
+    }
+    
+    /**
+     * Pings the user's server with the PacketReplyTimeout as defined
+     * in SmackConfiguration.
+     * 
+     * @return true if successful, otherwise false
+     */
+    public boolean pingMyServer() {
+        return pingMyServer(SmackConfiguration.getPacketReplyTimeout());
+    }
+    
+    /**
+     * Returns true if XMPP Ping is supported by a given JID
+     * 
+     * @param jid
+     * @return
+     */
+    public boolean isPingSupported(String jid) {
+        try {
+            DiscoverInfo result =
+                ServiceDiscoveryManager.getInstanceFor(connection).discoverInfo(jid);
+            return result.containsFeature(NAMESPACE);
+        }
+        catch (XMPPException e) {
+            return false;
+        }
+    }
+    
+    /**
+     * Returns the time of the last successful Ping Pong with the 
+     * users server. If there was no successful Ping (e.g. because this
+     * feature is disabled) -1 will be returned.
+     *  
+     * @return
+     */
+    public long getLastSuccessfulPing() {
+        long taskLastSuccessfulPing = -1;
+        if (serverPingTask != null) {
+            taskLastSuccessfulPing = serverPingTask.getLastSucessfulPing();
+        }
+        return Math.max(taskLastSuccessfulPing, lastServerPingStamp);
+    }
+    
+    protected Set<PingFailedListener> getPingFailedListeners() {
+        return pingFailedListeners;
+    }
+    
+    private class PingConnectionListener extends AbstractConnectionListener {
+
+        @Override
+        public void connectionClosed() {
+            maybeStopPingServerTask();
+        }
+
+        @Override
+        public void connectionClosedOnError(Exception arg0) {
+            maybeStopPingServerTask();
+        }
+
+        @Override
+        public void reconnectionSuccessful() {
+            maybeStartPingServerTask();
+        }
+
+    }
+    
+    private void maybeStartPingServerTask() {
+        if (serverPingTask != null) {
+            serverPingTask.setDone();
+            serverPingThread.interrupt();
+            serverPingTask = null;
+            serverPingThread = null;
+            System.err.println("Smack PingManger: Found existing serverPingTask");
+        }
+        
+        if (pingInterval > 0) {
+            serverPingTask = new ServerPingTask(connection, pingInterval);
+            serverPingThread = new Thread(serverPingTask);
+            serverPingThread.setDaemon(true);
+            serverPingThread.setName("Smack Ping Server Task (" + connection.getServiceName() + ")");
+            serverPingThread.start();
+        }
+    }
+    
+    private void maybeStopPingServerTask() {
+        if (serverPingThread != null) {
+            serverPingTask.setDone();
+            serverPingThread.interrupt();
+        }
+    }
+
+    private class PingPacketListener implements PacketListener {
+
+        public PingPacketListener() {
+        }
+        
+        /**
+         * Sends a Pong for every Ping
+         */
+        public void processPacket(Packet packet) {
+            if (pingMinDelta > 0) {
+                // Ping flood protection enabled
+                long currentMillies = System.currentTimeMillis();
+                long delta = currentMillies - lastPingStamp;
+                lastPingStamp = currentMillies;
+                if (delta < pingMinDelta) {
+                    return;
+                }
+            }
+            Pong pong = new Pong((Ping)packet);
+            connection.sendPacket(pong);
+        }
+    }
+}

source/org/jivesoftware/smackx/ping/ServerPingTask.java

@@ -0,0 +1,120 @@
+/**
+ * Copyright 2012 Florian Schmaus
+ *
+ * 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.smackx.ping;
+
+import java.lang.ref.WeakReference;
+import java.util.Set;
+
+import org.jivesoftware.smack.Connection;
+
+class ServerPingTask implements Runnable {
+    
+    // This has to be a weak reference because IIRC all threads are roots
+    // for objects and we have a new thread here that should hold a strong
+    // reference to connection so that it can be GCed.
+    private WeakReference<Connection> weakConnection;
+    private int pingInterval;
+    private volatile long lastSuccessfulPing = -1;
+    
+    private int delta = 1000; // 1 seconds
+    private int tries = 3; // 3 tries
+    
+    protected ServerPingTask(Connection connection, int pingIntervall) {
+        this.weakConnection = new WeakReference<Connection>(connection);
+        this.pingInterval = pingIntervall;
+    }
+    
+    protected void setDone() {
+        this.pingInterval = -1;
+    }
+    
+    protected void setPingInterval(int pingIntervall) {
+        this.pingInterval = pingIntervall;
+    }
+    
+    protected int getIntInterval() {
+        return pingInterval;
+    }
+    
+    protected long getLastSucessfulPing() {
+        return lastSuccessfulPing;
+    }
+    
+    public void run() {
+        sleep(60000);
+        
+        outerLoop:
+        while(pingInterval > 0) {
+            Connection connection = weakConnection.get();
+            if (connection == null) {
+                // connection has been collected by GC
+                // which means we can stop the thread by breaking the loop
+                break;
+            }
+            if (connection.isAuthenticated()) {
+                PingManager pingManager = PingManager.getInstaceFor(connection);
+                boolean res = false;
+                
+                for(int i = 0; i < tries; i++) {
+                    if (i != 0) {
+                        try {
+                            Thread.sleep(delta);
+                        } catch (InterruptedException e) {
+                            // We received an interrupt
+                            // This only happens if we should stop pinging
+                            break outerLoop;
+                        }
+                    }
+                    res = pingManager.pingMyServer();
+                    // stop when we receive a pong back
+                    if (res) {
+                        lastSuccessfulPing = System.currentTimeMillis();
+                        break;
+                    }
+                }
+                if (!res) {
+                    Set<PingFailedListener> pingFailedListeners = pingManager.getPingFailedListeners();
+                    for (PingFailedListener l : pingFailedListeners) {
+                        l.pingFailed();
+                    }
+                }
+            }
+            sleep();
+        }
+    }
+    
+    /*
+     * If pingInterval > 0 sleeps a minimum of pingInterval
+     */
+    private void sleep(int extraSleepTime) {
+        int totalSleep = pingInterval + extraSleepTime;
+        if (totalSleep > 0) {
+            try {
+                Thread.sleep(totalSleep);
+            } catch (InterruptedException e) {
+                /* Ignore */
+            }
+        }
+    }
+    
+    /**
+     * Sleeps the amount of pingInterval
+     */
+    private void sleep() {
+        sleep(0);
+    }
+}

source/org/jivesoftware/smackx/provider/PingProvider.java

@@ -0,0 +1,32 @@
+/**
+ * Copyright 2012 Florian Schmaus
+ *
+ * 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.smackx.provider;
+
+import org.jivesoftware.smack.packet.IQ;
+import org.jivesoftware.smack.provider.IQProvider;
+import org.jivesoftware.smackx.packet.Ping;
+import org.xmlpull.v1.XmlPullParser;
+
+public class PingProvider implements IQProvider {
+    
+    public IQ parseIQ(XmlPullParser parser) throws Exception {
+        // No need to use the ping constructor with arguments. IQ will already
+        // have filled out all relevant fields ('from', 'to', 'id').
+        return new Ping();
+    }
+
+}

test-unit/org/jivesoftware/smackx/ping/PingPongTest.java

@@ -0,0 +1,38 @@
+/**
+ * Copyright 2012 Florian Schmaus
+ *
+ * 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.smackx.ping;
+
+import static org.junit.Assert.assertEquals;
+
+import org.jivesoftware.smackx.packet.Ping;
+import org.jivesoftware.smackx.packet.Pong;
+import org.junit.Test;
+
+public class PingPongTest {
+
+    @Test
+    public void createPongfromPingTest() {
+        Ping ping = new Ping("from@sender.local/resourceFrom", "to@receiver.local/resourceTo");
+
+        // create a pong from a ping
+        Pong pong = new Pong(ping);
+
+        assertEquals(pong.getFrom(), ping.getTo());
+        assertEquals(pong.getTo(), ping.getFrom());
+        assertEquals(pong.getPacketID(), ping.getPacketID());
+    }
+
+}