507 lines
16 KiB
Python
507 lines
16 KiB
Python
# -*- coding:utf-8 -*-
|
|
## src/common/caps_cache.py
|
|
##
|
|
## Copyright (C) 2007 Tomasz Melcer <liori AT exroot.org>
|
|
## Travis Shirk <travis AT pobox.com>
|
|
## Copyright (C) 2007-2014 Yann Leboulanger <asterix AT lagaule.org>
|
|
## Copyright (C) 2008 Brendan Taylor <whateley AT gmail.com>
|
|
## Jonathan Schleifer <js-gajim AT webkeks.org>
|
|
## Copyright (C) 2008-2009 Stephan Erb <steve-e AT h3c.de>
|
|
##
|
|
## This file is part of Gajim.
|
|
##
|
|
## Gajim is free software; you can redistribute it and/or modify
|
|
## it under the terms of the GNU General Public License as published
|
|
## by the Free Software Foundation; version 3 only.
|
|
##
|
|
## Gajim is distributed in the hope that it will be useful,
|
|
## but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
## GNU General Public License for more details.
|
|
##
|
|
## You should have received a copy of the GNU General Public License
|
|
## along with Gajim. If not, see <http://www.gnu.org/licenses/>.
|
|
##
|
|
|
|
"""
|
|
Module containing all XEP-115 (Entity Capabilities) related classes
|
|
|
|
Basic Idea:
|
|
CapsCache caches features to hash relationships. The cache is queried
|
|
through ClientCaps objects which are hold by contact instances.
|
|
"""
|
|
|
|
import base64
|
|
import hashlib
|
|
from collections import namedtuple
|
|
|
|
import logging
|
|
log = logging.getLogger('gajim.c.caps_cache')
|
|
|
|
import nbxmpp
|
|
from nbxmpp import (NS_XHTML_IM, NS_ESESSION, NS_CHATSTATES,
|
|
NS_JINGLE_ICE_UDP, NS_JINGLE_RTP_AUDIO, NS_JINGLE_RTP_VIDEO,
|
|
NS_JINGLE_FILE_TRANSFER_5)
|
|
# Features where we cannot safely assume that the other side supports them
|
|
FEATURE_BLACKLIST = [NS_CHATSTATES, NS_XHTML_IM, NS_ESESSION,
|
|
NS_JINGLE_ICE_UDP, NS_JINGLE_RTP_AUDIO, NS_JINGLE_RTP_VIDEO,
|
|
NS_JINGLE_FILE_TRANSFER_5]
|
|
from gajim.common import app
|
|
# Query entry status codes
|
|
NEW = 0
|
|
QUERIED = 1
|
|
CACHED = 2 # got the answer
|
|
FAKED = 3 # allow NullClientCaps to behave as it has a cached item
|
|
|
|
################################################################################
|
|
### Public API of this module
|
|
################################################################################
|
|
|
|
capscache = None
|
|
muc_caps_cache = None
|
|
def initialize(logger):
|
|
"""
|
|
Initialize this module
|
|
"""
|
|
global capscache
|
|
global muc_caps_cache
|
|
capscache = CapsCache(logger)
|
|
muc_caps_cache = MucCapsCache()
|
|
|
|
def client_supports(client_caps, requested_feature):
|
|
lookup_item = client_caps.get_cache_lookup_strategy()
|
|
cache_item = lookup_item(capscache)
|
|
|
|
supported_features = cache_item.features
|
|
if requested_feature in supported_features:
|
|
return True
|
|
elif not supported_features and cache_item.status in (NEW, QUERIED, FAKED):
|
|
# assume feature is supported, if we don't know yet, what the client
|
|
# is capable of
|
|
return requested_feature not in FEATURE_BLACKLIST
|
|
else:
|
|
return False
|
|
|
|
def create_suitable_client_caps(node, caps_hash, hash_method, fjid=None):
|
|
"""
|
|
Create and return a suitable ClientCaps object for the given node,
|
|
caps_hash, hash_method combination.
|
|
"""
|
|
if not node or not caps_hash:
|
|
if fjid:
|
|
client_caps = NoClientCaps(fjid)
|
|
else:
|
|
# improper caps, ignore client capabilities.
|
|
client_caps = NullClientCaps()
|
|
elif not hash_method:
|
|
client_caps = OldClientCaps(caps_hash, node)
|
|
else:
|
|
client_caps = ClientCaps(caps_hash, node, hash_method)
|
|
return client_caps
|
|
|
|
def compute_caps_hash(identities, features, dataforms=None, hash_method='sha-1'):
|
|
"""
|
|
Compute caps hash according to XEP-0115, V1.5
|
|
|
|
dataforms are nbxmpp.DataForms objects as common.dataforms don't allow several
|
|
values without a field type list-multi
|
|
"""
|
|
if dataforms is None:
|
|
dataforms = []
|
|
def sort_identities_func(i1, i2):
|
|
cat1 = i1['category']
|
|
cat2 = i2['category']
|
|
if cat1 < cat2:
|
|
return -1
|
|
if cat1 > cat2:
|
|
return 1
|
|
type1 = i1.get('type', '')
|
|
type2 = i2.get('type', '')
|
|
if type1 < type2:
|
|
return -1
|
|
if type1 > type2:
|
|
return 1
|
|
lang1 = i1.get('xml:lang', '')
|
|
lang2 = i2.get('xml:lang', '')
|
|
if lang1 < lang2:
|
|
return -1
|
|
if lang1 > lang2:
|
|
return 1
|
|
return 0
|
|
|
|
def sort_dataforms_func(d1, d2):
|
|
f1 = d1.getField('FORM_TYPE')
|
|
f2 = d2.getField('FORM_TYPE')
|
|
if f1 and f2 and (f1.getValue() < f2.getValue()):
|
|
return -1
|
|
return 1
|
|
|
|
S = ''
|
|
from functools import cmp_to_key
|
|
identities.sort(key=cmp_to_key(sort_identities_func))
|
|
for i in identities:
|
|
c = i['category']
|
|
type_ = i.get('type', '')
|
|
lang = i.get('xml:lang', '')
|
|
name = i.get('name', '')
|
|
S += '%s/%s/%s/%s<' % (c, type_, lang, name)
|
|
features.sort()
|
|
for f in features:
|
|
S += '%s<' % f
|
|
dataforms.sort(key=cmp_to_key(sort_dataforms_func))
|
|
for dataform in dataforms:
|
|
# fields indexed by var
|
|
fields = {}
|
|
for f in dataform.getChildren():
|
|
fields[f.getVar()] = f
|
|
form_type = fields.get('FORM_TYPE')
|
|
if form_type:
|
|
S += form_type.getValue() + '<'
|
|
del fields['FORM_TYPE']
|
|
for var in sorted(fields.keys()):
|
|
S += '%s<' % var
|
|
values = sorted(fields[var].getValues())
|
|
for value in values:
|
|
S += '%s<' % value
|
|
|
|
if hash_method == 'sha-1':
|
|
hash_ = hashlib.sha1(S.encode('utf-8'))
|
|
elif hash_method == 'md5':
|
|
hash_ = hashlib.md5(S.encode('utf-8'))
|
|
else:
|
|
return ''
|
|
return base64.b64encode(hash_.digest()).decode('utf-8')
|
|
|
|
|
|
################################################################################
|
|
### Internal classes of this module
|
|
################################################################################
|
|
|
|
class AbstractClientCaps(object):
|
|
"""
|
|
Base class representing a client and its capabilities as advertised by a
|
|
caps tag in a presence
|
|
"""
|
|
def __init__(self, caps_hash, node):
|
|
self._hash = caps_hash
|
|
self._node = node
|
|
self._hash_method = None
|
|
|
|
def get_discover_strategy(self):
|
|
return self._discover
|
|
|
|
def _discover(self, connection, jid):
|
|
"""
|
|
To be implemented by subclassess
|
|
"""
|
|
raise NotImplementedError
|
|
|
|
def get_cache_lookup_strategy(self):
|
|
return self._lookup_in_cache
|
|
|
|
def _lookup_in_cache(self, caps_cache):
|
|
"""
|
|
To be implemented by subclassess
|
|
"""
|
|
raise NotImplementedError
|
|
|
|
def get_hash_validation_strategy(self):
|
|
return self._is_hash_valid
|
|
|
|
def _is_hash_valid(self, identities, features, dataforms):
|
|
"""
|
|
To be implemented by subclassess
|
|
"""
|
|
raise NotImplementedError
|
|
|
|
|
|
class ClientCaps(AbstractClientCaps):
|
|
"""
|
|
The current XEP-115 implementation
|
|
"""
|
|
def __init__(self, caps_hash, node, hash_method):
|
|
AbstractClientCaps.__init__(self, caps_hash, node)
|
|
assert hash_method != 'old'
|
|
self._hash_method = hash_method
|
|
|
|
def _lookup_in_cache(self, caps_cache):
|
|
return caps_cache[(self._hash_method, self._hash)]
|
|
|
|
def _discover(self, connection, jid):
|
|
connection.discoverInfo(jid, '%s#%s' % (self._node, self._hash))
|
|
|
|
def _is_hash_valid(self, identities, features, dataforms):
|
|
computed_hash = compute_caps_hash(identities, features,
|
|
dataforms=dataforms, hash_method=self._hash_method)
|
|
return computed_hash == self._hash
|
|
|
|
|
|
class OldClientCaps(AbstractClientCaps):
|
|
"""
|
|
Old XEP-115 implemtation. Kept around for background competability
|
|
"""
|
|
def __init__(self, caps_hash, node):
|
|
AbstractClientCaps.__init__(self, caps_hash, node)
|
|
self._hash_method = 'old'
|
|
|
|
def _lookup_in_cache(self, caps_cache):
|
|
return caps_cache[('old', self._node + '#' + self._hash)]
|
|
|
|
def _discover(self, connection, jid):
|
|
connection.discoverInfo(jid)
|
|
|
|
def _is_hash_valid(self, identities, features, dataforms):
|
|
return True
|
|
|
|
class NoClientCaps(AbstractClientCaps):
|
|
"""
|
|
For clients that don't support XEP-0115
|
|
"""
|
|
def __init__(self, fjid):
|
|
AbstractClientCaps.__init__(self, fjid, fjid)
|
|
self._hash_method = 'no'
|
|
|
|
def _lookup_in_cache(self, caps_cache):
|
|
return caps_cache[('no', self._node)]
|
|
|
|
def _discover(self, connection, jid):
|
|
connection.discoverInfo(jid)
|
|
|
|
def _is_hash_valid(self, identities, features, dataforms):
|
|
return True
|
|
|
|
class NullClientCaps(AbstractClientCaps):
|
|
"""
|
|
This is a NULL-Object to streamline caps handling if a client has not
|
|
advertised any caps or has advertised them in an improper way
|
|
|
|
Assumes (almost) everything is supported.
|
|
"""
|
|
_instance = None
|
|
def __new__(cls, *args, **kwargs):
|
|
"""
|
|
Make it a singleton.
|
|
"""
|
|
if not cls._instance:
|
|
cls._instance = super(NullClientCaps, cls).__new__(
|
|
cls, *args, **kwargs)
|
|
return cls._instance
|
|
|
|
def __init__(self):
|
|
AbstractClientCaps.__init__(self, None, None)
|
|
self._hash_method = 'dummy'
|
|
|
|
def _lookup_in_cache(self, caps_cache):
|
|
# lookup something which does not exist to get a new CacheItem created
|
|
cache_item = caps_cache[('dummy', '')]
|
|
# Mark the item as cached so that protocol/caps.py does not update it
|
|
cache_item.status = FAKED
|
|
return cache_item
|
|
|
|
def _discover(self, connection, jid):
|
|
pass
|
|
|
|
def _is_hash_valid(self, identities, features, dataforms):
|
|
return False
|
|
|
|
|
|
class CapsCache(object):
|
|
"""
|
|
This object keeps the mapping between caps data and real disco features they
|
|
represent, and provides simple way to query that info
|
|
"""
|
|
def __init__(self, logger=None):
|
|
# our containers:
|
|
# __cache is a dictionary mapping: pair of hash method and hash maps
|
|
# to CapsCacheItem object
|
|
# __CacheItem is a class that stores data about particular
|
|
# client (hash method/hash pair)
|
|
self.__cache = {}
|
|
|
|
class CacheItem(object):
|
|
# __names is a string cache; every string long enough is given
|
|
# another object, and we will have plenty of identical long
|
|
# strings. therefore we can cache them
|
|
__names = {}
|
|
|
|
def __init__(self, hash_method, hash_, logger):
|
|
# cached into db
|
|
self.hash_method = hash_method
|
|
self.hash = hash_
|
|
self._features = []
|
|
self._identities = []
|
|
self._logger = logger
|
|
|
|
self.status = NEW
|
|
self._recently_seen = False
|
|
|
|
def _get_features(self):
|
|
return self._features
|
|
|
|
def _set_features(self, value):
|
|
self._features = []
|
|
for feature in value:
|
|
self._features.append(self.__names.setdefault(feature, feature))
|
|
|
|
features = property(_get_features, _set_features)
|
|
|
|
def _get_identities(self):
|
|
list_ = []
|
|
for i in self._identities:
|
|
# transforms it back in a dict
|
|
d = dict()
|
|
d['category'] = i[0]
|
|
if i[1]:
|
|
d['type'] = i[1]
|
|
if i[2]:
|
|
d['xml:lang'] = i[2]
|
|
if i[3]:
|
|
d['name'] = i[3]
|
|
list_.append(d)
|
|
return list_
|
|
|
|
def _set_identities(self, value):
|
|
self._identities = []
|
|
for identity in value:
|
|
# dict are not hashable, so transform it into a tuple
|
|
t = (identity['category'], identity.get('type'),
|
|
identity.get('xml:lang'), identity.get('name'))
|
|
self._identities.append(self.__names.setdefault(t, t))
|
|
|
|
identities = property(_get_identities, _set_identities)
|
|
|
|
def set_and_store(self, identities, features):
|
|
self.identities = identities
|
|
self.features = features
|
|
if self.hash_method != 'no':
|
|
self._logger.add_caps_entry(self.hash_method, self.hash,
|
|
identities, features)
|
|
self.status = CACHED
|
|
|
|
def update_last_seen(self):
|
|
if not self._recently_seen:
|
|
self._recently_seen = True
|
|
if self.hash_method != 'no':
|
|
self._logger.update_caps_time(self.hash_method,
|
|
self.hash)
|
|
|
|
def is_valid(self):
|
|
"""
|
|
Returns True if identities and features for this cache item
|
|
are known.
|
|
"""
|
|
return self.status in (CACHED, FAKED)
|
|
|
|
self.__CacheItem = CacheItem
|
|
self.logger = logger
|
|
|
|
def initialize_from_db(self):
|
|
self._remove_outdated_caps()
|
|
for hash_method, hash_, identities, features in \
|
|
self.logger.iter_caps_data():
|
|
x = self[(hash_method, hash_)]
|
|
x.identities = identities
|
|
x.features = features
|
|
x.status = CACHED
|
|
|
|
def _remove_outdated_caps(self):
|
|
"""
|
|
Remove outdated values from the db
|
|
"""
|
|
self.logger.clean_caps_table()
|
|
|
|
def __getitem__(self, caps):
|
|
if caps in self.__cache:
|
|
return self.__cache[caps]
|
|
|
|
hash_method, hash_ = caps
|
|
|
|
x = self.__CacheItem(hash_method, hash_, self.logger)
|
|
self.__cache[(hash_method, hash_)] = x
|
|
return x
|
|
|
|
def query_client_of_jid_if_unknown(self, connection, jid, client_caps):
|
|
"""
|
|
Start a disco query to determine caps (node, ver, exts). Won't query if
|
|
the data is already in cache
|
|
"""
|
|
lookup_cache_item = client_caps.get_cache_lookup_strategy()
|
|
q = lookup_cache_item(self)
|
|
|
|
if q.status == NEW:
|
|
# do query for bare node+hash pair
|
|
# this will create proper object
|
|
q.status = QUERIED
|
|
discover = client_caps.get_discover_strategy()
|
|
discover(connection, jid)
|
|
else:
|
|
q.update_last_seen()
|
|
|
|
def forget_caps(self, client_caps):
|
|
hash_method = client_caps._hash_method
|
|
hash = client_caps._hash
|
|
key = (hash_method, hash)
|
|
if key in self.__cache:
|
|
del self.__cache[key]
|
|
|
|
|
|
class MucCapsCache:
|
|
|
|
DiscoInfo = namedtuple('DiscoInfo', ['identities', 'features', 'data'])
|
|
|
|
def __init__(self):
|
|
self.cache = {}
|
|
|
|
def append(self, stanza):
|
|
jid = stanza.getFrom()
|
|
identities, features, data = [], [], []
|
|
query_childs = stanza.getQueryChildren()
|
|
if not query_childs:
|
|
app.log('gajim.muc').warning('%s returned empty disco info', jid)
|
|
return
|
|
|
|
for child in query_childs:
|
|
if child.getName() == 'identity':
|
|
attr = {}
|
|
for key in child.getAttrs().keys():
|
|
attr[key] = child.getAttr(key)
|
|
identities.append(attr)
|
|
elif child.getName() == 'feature':
|
|
features.append(child.getAttr('var'))
|
|
elif child.getName() == 'x':
|
|
if child.getNamespace() == nbxmpp.NS_DATA:
|
|
data.append(nbxmpp.DataForm(node=child))
|
|
|
|
if nbxmpp.NS_MUC not in features:
|
|
# Not a MUC, dont cache info
|
|
return
|
|
|
|
self.cache[jid] = self.DiscoInfo(identities, features, data)
|
|
|
|
def is_cached(self, jid):
|
|
return jid in self.cache
|
|
|
|
def supports(self, jid, feature):
|
|
if jid in self.cache:
|
|
if feature in self.cache[jid].features:
|
|
return True
|
|
return False
|
|
|
|
def has_mam(self, jid):
|
|
try:
|
|
if nbxmpp.NS_MAM_2 in self.cache[jid].features:
|
|
return True
|
|
if nbxmpp.NS_MAM_1 in self.cache[jid].features:
|
|
return True
|
|
except (KeyError, AttributeError):
|
|
return False
|
|
|
|
def get_mam_namespace(self, jid):
|
|
try:
|
|
if nbxmpp.NS_MAM_2 in self.cache[jid].features:
|
|
return nbxmpp.NS_MAM_2
|
|
elif nbxmpp.NS_MAM_1 in self.cache[jid].features:
|
|
return nbxmpp.NS_MAM_1
|
|
except (KeyError, AttributeError):
|
|
return
|