导航菜单
登录 注册

页面标题

页面副标题

95爱播免登录版 v3.1.9 - EntityCapsManager.java 源代码

正在查看： 95爱播免登录版 v3.1.9 应用的 EntityCapsManager.java JAVA 源代码文件

本页面展示 JAVA 反编译生成的源代码文件，支持语法高亮显示。 仅供安全研究与技术分析使用，严禁用于任何非法用途。请遵守相关法律法规。 


package org.jivesoftware.smackx.entitycaps;

import java.io.IOException;
import java.lang.ref.WeakReference;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Queue;
import java.util.TreeSet;
import java.util.WeakHashMap;
import java.util.concurrent.ConcurrentLinkedQueue;
import org.jivesoftware.smack.Connection;
import org.jivesoftware.smack.ConnectionCreationListener;
import org.jivesoftware.smack.ConnectionListener;
import org.jivesoftware.smack.PacketInterceptor;
import org.jivesoftware.smack.PacketListener;
import org.jivesoftware.smack.SmackConfiguration;
import org.jivesoftware.smack.XMPPConnection;
import org.jivesoftware.smack.XMPPException;
import org.jivesoftware.smack.filter.AndFilter;
import org.jivesoftware.smack.filter.NotFilter;
import org.jivesoftware.smack.filter.PacketExtensionFilter;
import org.jivesoftware.smack.filter.PacketFilter;
import org.jivesoftware.smack.filter.PacketTypeFilter;
import org.jivesoftware.smack.packet.IQ;
import org.jivesoftware.smack.packet.Packet;
import org.jivesoftware.smack.packet.PacketExtension;
import org.jivesoftware.smack.packet.Presence;
import org.jivesoftware.smack.util.Base64;
import org.jivesoftware.smack.util.Cache;
import org.jivesoftware.smackx.FormField;
import org.jivesoftware.smackx.NodeInformationProvider;
import org.jivesoftware.smackx.ServiceDiscoveryManager;
import org.jivesoftware.smackx.entitycaps.cache.EntityCapsPersistentCache;
import org.jivesoftware.smackx.entitycaps.packet.CapsExtension;
import org.jivesoftware.smackx.packet.DataForm;
import org.jivesoftware.smackx.packet.DiscoverInfo;
import org.jivesoftware.smackx.packet.DiscoverItems;

public class EntityCapsManager {
    public static final String ELEMENT = "c";
    private static final String ENTITY_NODE = "http://www.igniterealtime.org/projects/smack";
    public static final String NAMESPACE = "http://jabber.org/protocol/caps";
    private static final Map<String, MessageDigest> SUPPORTED_HASHES;
    protected static Map<String, DiscoverInfo> caps;
    private static Map<Connection, EntityCapsManager> instances;
    protected static Map<String, NodeVerHash> jidCaps;
    protected static EntityCapsPersistentCache persistentCache;
    private String currentCapsVersion;
    private boolean entityCapsEnabled;
    private Queue<String> lastLocalCapsVersions;
    private boolean presenceSend;
    private ServiceDiscoveryManager sdm;
    private WeakReference<Connection> weakRefConnection;

    public static class NodeVerHash {
        private String hash;
        private String node;
        private String nodeVer;
        private String ver;

        NodeVerHash(String str, String str2, String str3) {
            this.node = str;
            this.ver = str2;
            this.hash = str3;
            this.nodeVer = String.valueOf(str) + "#" + str2;
        }

        public String getHash() {
            return this.hash;
        }

        public String getNode() {
            return this.node;
        }

        public String getNodeVer() {
            return this.nodeVer;
        }

        public String getVer() {
            return this.ver;
        }
    }

    static {
        HashMap hashMap = new HashMap();
        SUPPORTED_HASHES = hashMap;
        instances = Collections.synchronizedMap(new WeakHashMap());
        caps = new Cache(1000, -1L);
        jidCaps = new Cache(10000, -1L);
        Connection.addConnectionCreationListener(new ConnectionCreationListener() {
            public void connectionCreated(Connection connection) {
                if (connection instanceof XMPPConnection) {
                    new EntityCapsManager(connection, null);
                }
            }
        });
        try {
            hashMap.put("sha-1", MessageDigest.getInstance("SHA-1"));
        } catch (NoSuchAlgorithmException unused) {
        }
    }

    private EntityCapsManager(Connection connection) {
        this.presenceSend = false;
        this.lastLocalCapsVersions = new ConcurrentLinkedQueue();
        this.weakRefConnection = new WeakReference<>(connection);
        this.sdm = ServiceDiscoveryManager.getInstanceFor(connection);
        init();
    }

    public static void addDiscoverInfoByNode(String str, DiscoverInfo discoverInfo) {
        caps.put(str, discoverInfo);
        EntityCapsPersistentCache entityCapsPersistentCache = persistentCache;
        if (entityCapsPersistentCache != null) {
            entityCapsPersistentCache.addDiscoverInfoByNodePersistent(str, discoverInfo);
        }
    }

    private static void formFieldValuesToCaps(Iterator<String> it, StringBuilder sb) {
        TreeSet treeSet = new TreeSet();
        while (it.hasNext()) {
            treeSet.add(it.next());
        }
        Iterator it2 = treeSet.iterator();
        while (it2.hasNext()) {
            sb.append((String) it2.next());
            sb.append("<");
        }
    }

    protected static String generateVerificationString(DiscoverInfo discoverInfo, String str) {
        MessageDigest messageDigest = SUPPORTED_HASHES.get(str.toLowerCase());
        FormField formField = null;
        if (messageDigest == null) {
            return null;
        }
        DataForm dataForm = (DataForm) discoverInfo.getExtension("x", "jabber:x:data");
        StringBuilder sb = new StringBuilder();
        TreeSet<DiscoverInfo.Identity> treeSet = new TreeSet();
        Iterator<DiscoverInfo.Identity> identities = discoverInfo.getIdentities();
        while (identities.hasNext()) {
            treeSet.add(identities.next());
        }
        for (DiscoverInfo.Identity identity : treeSet) {
            sb.append(identity.getCategory());
            sb.append("/");
            sb.append(identity.getType());
            sb.append("/");
            sb.append(identity.getLanguage() == null ? "" : identity.getLanguage());
            sb.append("/");
            sb.append(identity.getName() == null ? "" : identity.getName());
            sb.append("<");
        }
        TreeSet treeSet2 = new TreeSet();
        Iterator<DiscoverInfo.Feature> features = discoverInfo.getFeatures();
        while (features.hasNext()) {
            treeSet2.add(features.next().getVar());
        }
        Iterator it = treeSet2.iterator();
        while (it.hasNext()) {
            sb.append((String) it.next());
            sb.append("<");
        }
        if (dataForm != null && dataForm.hasHiddenFormTypeField()) {
            synchronized (dataForm) {
                TreeSet<FormField> treeSet3 = new TreeSet(new Comparator<FormField>() {
                    @Override
                    public int compare(FormField formField2, FormField formField3) {
                        return formField2.getVariable().compareTo(formField3.getVariable());
                    }
                });
                Iterator<FormField> fields = dataForm.getFields();
                while (fields.hasNext()) {
                    FormField next = fields.next();
                    if (next.getVariable().equals("FORM_TYPE")) {
                        formField = next;
                    } else {
                        treeSet3.add(next);
                    }
                }
                if (formField != null) {
                    formFieldValuesToCaps(formField.getValues(), sb);
                }
                for (FormField formField2 : treeSet3) {
                    sb.append(formField2.getVariable());
                    sb.append("<");
                    formFieldValuesToCaps(formField2.getValues(), sb);
                }
            }
        }
        return Base64.encodeBytes(messageDigest.digest(sb.toString().getBytes()));
    }

    public static DiscoverInfo getDiscoverInfoByUser(String str) {
        NodeVerHash nodeVerHash = jidCaps.get(str);
        if (nodeVerHash == null) {
            return null;
        }
        return getDiscoveryInfoByNodeVer(nodeVerHash.nodeVer);
    }

    public static DiscoverInfo getDiscoveryInfoByNodeVer(String str) {
        DiscoverInfo discoverInfo = caps.get(str);
        return discoverInfo != null ? new DiscoverInfo(discoverInfo) : discoverInfo;
    }

    public static synchronized EntityCapsManager getInstanceFor(Connection connection) {
        synchronized (EntityCapsManager.class) {
            if (!(connection instanceof XMPPConnection)) {
                return null;
            }
            if (SUPPORTED_HASHES.size() <= 0) {
                return null;
            }
            EntityCapsManager entityCapsManager = instances.get(connection);
            if (entityCapsManager == null) {
                entityCapsManager = new EntityCapsManager(connection);
            }
            return entityCapsManager;
        }
    }

    public static NodeVerHash getNodeVerHashByJid(String str) {
        return jidCaps.get(str);
    }

    public static String getNodeVersionByJid(String str) {
        NodeVerHash nodeVerHash = jidCaps.get(str);
        if (nodeVerHash != null) {
            return nodeVerHash.nodeVer;
        }
        return null;
    }

    private void init() {
        Connection connection = this.weakRefConnection.get();
        instances.put(connection, this);
        connection.addConnectionListener(new ConnectionListener() {
            public void connectionClosed() {
                EntityCapsManager.this.presenceSend = false;
                EntityCapsManager.instances.remove(EntityCapsManager.this.weakRefConnection.get());
            }

            public void connectionClosedOnError(Exception exc) {
                EntityCapsManager.this.presenceSend = false;
            }

            public void reconnectingIn(int i) {
            }

            public void reconnectionFailed(Exception exc) {
            }

            public void reconnectionSuccessful() {
            }
        });
        updateLocalEntityCaps();
        if (SmackConfiguration.autoEnableEntityCaps()) {
            enableEntityCaps();
        }
        connection.addPacketListener(new PacketListener() {
            public void processPacket(Packet packet) {
                if (EntityCapsManager.this.entityCapsEnabled()) {
                    CapsExtension capsExtension = (CapsExtension) packet.getExtension(EntityCapsManager.ELEMENT, EntityCapsManager.NAMESPACE);
                    String lowerCase = capsExtension.getHash().toLowerCase();
                    if (EntityCapsManager.SUPPORTED_HASHES.containsKey(lowerCase)) {
                        EntityCapsManager.jidCaps.put(packet.getFrom(), new NodeVerHash(capsExtension.getNode(), capsExtension.getVer(), lowerCase));
                    }
                }
            }
        }, new AndFilter(new PacketFilter[]{new PacketTypeFilter(Presence.class), new PacketExtensionFilter(ELEMENT, NAMESPACE)}));
        connection.addPacketListener(new PacketListener() {
            public void processPacket(Packet packet) {
                EntityCapsManager.jidCaps.remove(packet.getFrom());
            }
        }, new AndFilter(new PacketFilter[]{new PacketTypeFilter(Presence.class), new NotFilter(new PacketExtensionFilter(ELEMENT, NAMESPACE))}));
        connection.addPacketSendingListener(new PacketListener() {
            public void processPacket(Packet packet) {
                EntityCapsManager.this.presenceSend = true;
            }
        }, new PacketTypeFilter(Presence.class));
        connection.addPacketInterceptor(new PacketInterceptor() {
            public void interceptPacket(Packet packet) {
                if (EntityCapsManager.this.entityCapsEnabled) {
                    packet.addExtension(new CapsExtension(EntityCapsManager.ENTITY_NODE, EntityCapsManager.this.getCapsVersion(), "sha-1"));
                }
            }
        }, new PacketTypeFilter(Presence.class));
        this.sdm.setEntityCapsManager(this);
    }

    public static void setCapsMaxCacheSize(int i) {
        caps.setMaxCacheSize(i);
    }

    public static void setJidCapsMaxCacheSize(int i) {
        jidCaps.setMaxCacheSize(i);
    }

    public static void setPersistentCache(EntityCapsPersistentCache entityCapsPersistentCache) throws IOException {
        if (persistentCache != null) {
            throw new IllegalStateException("Entity Caps Persistent Cache was already set");
        }
        persistentCache = entityCapsPersistentCache;
        entityCapsPersistentCache.replay();
    }

    public static boolean verifyDiscoverInfoVersion(String str, String str2, DiscoverInfo discoverInfo) {
        return (discoverInfo.containsDuplicateIdentities() || discoverInfo.containsDuplicateFeatures() || verifyPacketExtensions(discoverInfo) || !str.equals(generateVerificationString(discoverInfo, str2))) ? false : true;
    }

    protected static boolean verifyPacketExtensions(DiscoverInfo discoverInfo) {
        LinkedList linkedList = new LinkedList();
        for (PacketExtension packetExtension : discoverInfo.getExtensions()) {
            if (packetExtension.getNamespace().equals("jabber:x:data")) {
                Iterator<FormField> fields = ((DataForm) packetExtension).getFields();
                while (fields.hasNext()) {
                    FormField next = fields.next();
                    if (next.getVariable().equals("FORM_TYPE")) {
                        Iterator it = linkedList.iterator();
                        while (it.hasNext()) {
                            if (next.equals((FormField) it.next())) {
                                return true;
                            }
                        }
                        linkedList.add(next);
                    }
                }
            }
        }
        return false;
    }

    public boolean areEntityCapsSupported(String str) {
        if (str == null) {
            return false;
        }
        try {
            return this.sdm.discoverInfo(str).containsFeature(NAMESPACE);
        } catch (XMPPException unused) {
            return false;
        }
    }

    public boolean areEntityCapsSupportedByServer() {
        return areEntityCapsSupported(this.weakRefConnection.get().getServiceName());
    }

    public void disableEntityCaps() {
        this.entityCapsEnabled = false;
        this.sdm.removeFeature(NAMESPACE);
    }

    public void enableEntityCaps() {
        this.sdm.addFeature(NAMESPACE);
        updateLocalEntityCaps();
        this.entityCapsEnabled = true;
    }

    public boolean entityCapsEnabled() {
        return this.entityCapsEnabled;
    }

    public String getCapsVersion() {
        return this.currentCapsVersion;
    }

    public String getLocalNodeVer() {
        return "http://www.igniterealtime.org/projects/smack#" + getCapsVersion();
    }

    public void removeUserCapsNode(String str) {
        jidCaps.remove(str);
    }

    public void updateLocalEntityCaps() {
        Connection connection = this.weakRefConnection.get();
        DiscoverInfo discoverInfo = new DiscoverInfo();
        discoverInfo.setType(IQ.Type.RESULT);
        discoverInfo.setNode(getLocalNodeVer());
        if (connection != null) {
            discoverInfo.setFrom(connection.getUser());
        }
        this.sdm.addDiscoverInfoTo(discoverInfo);
        this.currentCapsVersion = generateVerificationString(discoverInfo, "sha-1");
        addDiscoverInfoByNode("http://www.igniterealtime.org/projects/smack#" + this.currentCapsVersion, discoverInfo);
        if (this.lastLocalCapsVersions.size() > 10) {
            String poll = this.lastLocalCapsVersions.poll();
            this.sdm.removeNodeInformationProvider("http://www.igniterealtime.org/projects/smack#" + poll);
        }
        this.lastLocalCapsVersions.add(this.currentCapsVersion);
        caps.put(this.currentCapsVersion, discoverInfo);
        if (connection != null) {
            jidCaps.put(connection.getUser(), new NodeVerHash(ENTITY_NODE, this.currentCapsVersion, "sha-1"));
        }
        this.sdm.setNodeInformationProvider("http://www.igniterealtime.org/projects/smack#" + this.currentCapsVersion, new NodeInformationProvider() {
            List<String> features;
            List<DiscoverInfo.Identity> identities = new LinkedList(ServiceDiscoveryManager.getIdentities());
            List<PacketExtension> packetExtensions;

            {
                this.features = EntityCapsManager.this.sdm.getFeaturesList();
                this.packetExtensions = EntityCapsManager.this.sdm.getExtendedInfoAsList();
            }

            public List<String> getNodeFeatures() {
                return this.features;
            }

            public List<DiscoverInfo.Identity> getNodeIdentities() {
                return this.identities;
            }

            public List<DiscoverItems.Item> getNodeItems() {
                return null;
            }

            public List<PacketExtension> getNodePacketExtensions() {
                return this.packetExtensions;
            }
        });
        if (connection != null && connection.isAuthenticated() && this.presenceSend) {
            connection.sendPacket(new Presence(Presence.Type.available));
        }
    }

    EntityCapsManager(Connection connection, EntityCapsManager entityCapsManager) {
        this(connection);
    }
}