--- a/src/plugins/plugin_xep_0054.py	Sun Jan 15 16:00:41 2017 +0100
+++ b/src/plugins/plugin_xep_0054.py	Sun Jan 15 17:51:37 2017 +0100
@@ -24,10 +24,8 @@
 log = getLogger(__name__)
 from twisted.internet import threads, defer
 from twisted.words.protocols.jabber import jid
-from twisted.words.protocols.jabber.xmlstream import IQ
 from twisted.words.xish import domish
 from twisted.python.failure import Failure
-import os.path
 
 from zope.interface import implements
 
@@ -37,6 +35,7 @@
 from hashlib import sha1
 from sat.core import exceptions
 from sat.memory import persistent
+import mimetypes
 try:
     from PIL import Image
 except:
@@ -49,7 +48,7 @@
     from wokkel.subprotocols import XMPPHandler
 
 AVATAR_PATH = "avatars"
-AVATAR_DIM = (64, 64)
+AVATAR_DIM = (64, 64)  # FIXME: dim are not adapted to modern resolutions !
 
 IQ_GET = '/iq[@type="get"]'
 NS_VCARD = 'vcard-temp'
@@ -60,6 +59,7 @@
 VCARD_UPDATE = PRESENCE + '/x[@xmlns="' + NS_VCARD_UPDATE + '"]'
 
 CACHED_DATA = {'avatar', 'nick'}
+MAX_AGE = 60 * 60 * 24 * 365
 
 PLUGIN_INFO = {
     "name": "XEP 0054 Plugin",
@@ -80,36 +80,17 @@
     #      - get missing values
 
     def __init__(self, host):
-        log.info(_("Plugin XEP_0054 initialization"))
+        log.info(_(u"Plugin XEP_0054 initialization"))
         self.host = host
-        self.avatar_path = os.path.join(self.host.memory.getConfig('', 'local_dir'), AVATAR_PATH)
-        if not os.path.exists(self.avatar_path):
-            os.makedirs(self.avatar_path)
-        self.cache = {}
-        host.bridge.addMethod("getCard", ".plugin", in_sign='ss', out_sign='', method=self._getCard, async=True)
-        host.bridge.addMethod("getAvatarFile", ".plugin", in_sign='s', out_sign='s', method=self.getAvatarFile)
-        host.bridge.addMethod("getAvatar", ".plugin", in_sign='ss', out_sign='s', method=self._getAvatar, async=True)
-        host.bridge.addMethod("setAvatar", ".plugin", in_sign='ss', out_sign='', method=self.setAvatar, async=True)
-        host.trigger.add("presence_available", self.presenceAvailableTrigger)
-        host.memory.setSignalOnUpdate("avatar")
-        host.memory.setSignalOnUpdate("nick")
+        host.bridge.addMethod(u"avatarGet", u".plugin", in_sign=u'sbbs', out_sign=u's', method=self._getAvatar, async=True)
+        host.bridge.addMethod(u"avatarSet", u".plugin", in_sign=u'ss', out_sign=u'', method=self._setAvatar, async=True)
+        host.trigger.add(u"presence_available", self.presenceAvailableTrigger)
+        host.memory.setSignalOnUpdate(u"avatar")
+        host.memory.setSignalOnUpdate(u"nick")
 
     def getHandler(self, profile):
         return XEP_0054_handler(self)
 
-    def presenceAvailableTrigger(self, presence_elt, client):
-        if client.jid.userhost() in self.cache[client.profile]:
-            try:
-                avatar_hash = self.cache[client.profile][client.jid.userhost()]['avatar']
-            except KeyError:
-                log.info(u"No avatar in cache for {}".format(client.jid.userhost()))
-                return True
-            x_elt = domish.Element((NS_VCARD_UPDATE, 'x'))
-            x_elt.addElement('photo', content=avatar_hash)
-            presence_elt.addChild(x_elt)
-
-        return True
-
     def isRoom(self, client, entity_jid):
         """Tell if a jid is a MUC one
 
@@ -123,48 +104,86 @@
         else:
             return True
 
+    def getBareOrFull(self, client, jid_):
+        """use full jid if jid_ is an occupant of a room, bare jid else
+
+        @param jid_(jid.JID): entity to test
+        @return (jid.JID): bare or full jid
+        """
+        if jid_.resource:
+            if not self.isRoom(client, jid_):
+                return jid_.userhostJID()
+        return jid_
+
+    def presenceAvailableTrigger(self, presence_elt, client):
+        if client.jid.userhost() in client._cache_0054:
+            try:
+                avatar_hash = client._cache_0054[client.jid.userhost()]['avatar']
+            except KeyError:
+                log.info(u"No avatar in cache for {}".format(client.jid.userhost()))
+                return True
+            x_elt = domish.Element((NS_VCARD_UPDATE, 'x'))
+            x_elt.addElement('photo', content=avatar_hash)
+            presence_elt.addChild(x_elt)
+        return True
+
+    @defer.inlineCallbacks
+    def profileConnecting(self, profile):
+        client = self.host.getClient(profile)
+        client._cache_0054 = persistent.PersistentBinaryDict(NS_VCARD, profile)
+        yield client._cache_0054.load()
+        self._fillCachedValues(profile)
+
     def _fillCachedValues(self, profile):
-        #FIXME: this is really suboptimal, need to be reworked
-        #       the current naive approach keeps a map between all jids of all profiles
+        #FIXME: this may need to be reworked
+        #       the current naive approach keeps a map between all jids
         #       in persistent cache, then put avatar hashs in memory.
-        #       Hashes should be shared between profiles
-        for jid_s, data in self.cache[profile].iteritems():
+        #       Hashes should be shared between profiles (or not ? what
+        #       if the avatar is different depending on who is requesting it
+        #       this is not possible with vcard-tmp, but it is with XEP-0084).
+        #       Loading avatar on demand per jid may be a option to investigate.
+        client = self.host.getClient(profile)
+        for jid_s, data in client._cache_0054.iteritems():
             jid_ = jid.JID(jid_s)
             for name in CACHED_DATA:
                 try:
+                    value = data[name]
+                    if value is None:
+                        log.error(u"{name} value for {jid_} is None, ignoring".format(name=name, jid_=jid_))
+                        continue
                     self.host.memory.updateEntityData(jid_, name, data[name], silent=True, profile_key=profile)
                 except KeyError:
                     pass
 
-    @defer.inlineCallbacks
-    def profileConnecting(self, profile):
-        self.cache[profile] = persistent.PersistentBinaryDict(NS_VCARD, profile)
-        yield self.cache[profile].load()
-        self._fillCachedValues(profile)
-
-    def profileDisconnected(self, profile):
-        log.debug(u"Deleting profile cache for avatars")
-        del self.cache[profile]
-
     def updateCache(self, client, jid_, name, value):
         """update cache value
 
         save value in memory in case of change
         @param jid_(jid.JID): jid of the owner of the vcard
         @param name(str): name of the item which changed
-        @param value(unicode): new value of the item
+        @param value(unicode, None): new value of the item
+            None to delete
         """
-        if jid_.resource:
-            if not self.isRoom(client, jid_):
-                # VCard are retrieved with bare jid
-                # but MUC room is a special case
-                jid_ = jid.userhostJID()
+        jid_ = self.getBareOrFull(client, jid_)
+        jid_s = jid_.full()
 
-        self.host.memory.updateEntityData(jid_, name, value, profile_key=client.profile)
-        if name in CACHED_DATA:
-            jid_s = jid_.userhost()
-            self.cache[client.profile].setdefault(jid_s, {})[name] = value
-            self.cache[client.profile].force(jid_s)
+        if value is None:
+            try:
+                self.host.memory.delEntityDatum(jid_, name, client.profile)
+            except (KeyError, exceptions.UnknownEntityError):
+                pass
+            if name in CACHED_DATA:
+                try:
+                    del client._cache_0054[jid_s][name]
+                except KeyError:
+                    pass
+                else:
+                    client._cache_0054.force(jid_s)
+        else:
+            self.host.memory.updateEntityData(jid_, name, value, profile_key=client.profile)
+            if name in CACHED_DATA:
+                client._cache_0054.setdefault(jid_s, {})[name] = value
+                client._cache_0054.force(jid_s)
 
     def getCache(self, client, entity_jid, name):
         """return cached value for jid
@@ -172,105 +191,106 @@
         @param entity_jid: target contact
         @param name: name of the value ('nick' or 'avatar')
         @return: wanted value or None"""
-        if entity_jid.resource:
-            if not self.isRoom(client, entity_jid):
-                # VCard are retrieved with bare jid
-                # but MUC room is a special case
-                entity_jid = jid.userhostJID()
+        entity_jid = self.getBareOrFull(client, entity_jid)
         try:
             data = self.host.memory.getEntityData(entity_jid, [name], client.profile)
         except exceptions.UnknownEntityError:
             return None
         return data.get(name)
 
-    def _getFilename(self, hash_):
-        """Get filename from hash
-
-        @param hash_: hash of the avatar
-        @return (str): absolute filename of the avatar
-        """
-        return os.path.join(self.avatar_path, hash_)
-
-    def saveAvatarFile(self, data, hash_):
-        """Save the avatar picture if it doesn't already exists
-
-        @param data(str): binary image of the avatar
-        @param hash_(str): hash of the binary data (will be used for the filename)
-        """
-        filename = self._getFilename(hash_)
-        if not os.path.exists(filename):
-            with open(filename, 'wb') as file_:
-                file_.write(data)
-            log.debug(_(u"file saved to %s") % hash_)
+    def savePhoto(self, client, photo_elt, entity_jid):
+        """Parse a <PHOTO> photo_elt and save the picture"""
+        # XXX: this method is launched in a separate thread
+        try:
+            mime_type = unicode(photo_elt.elements(NS_VCARD, 'TYPE').next())
+        except StopIteration:
+            log.warning(u"no MIME type found, assuming image/png")
+            mime_type = u"image/png"
         else:
-            log.debug(_(u"file [%s] already in cache") % hash_)
+            if not mime_type:
+                log.warning(u"empty MIME type, assuming image/png")
+                mime_type = u"image/png"
+            elif mime_type not in ("image/gif", "image/jpeg", "image/png"):
+                if mime_type == "image/x-png":
+                    # XXX: this old MIME type is still used by some clients
+                    mime_type = "image/png"
+                else:
+                    # TODO: handle other image formats (svg?)
+                    log.warning(u"following avatar image format is not handled: {type} [{jid}]".format(
+                        type=mime_type, jid=entity_jid.full()))
+                    raise Failure(exceptions.DataError())
 
-    def savePhoto(self, photo_elt, target):
-        """Parse a <PHOTO> photo_elt and save the picture"""
+            ext = mimetypes.guess_extension(mime_type, strict=False)
+            assert ext is not None
+            log.debug(u'photo of type {type} with extension {ext} found [{jid}]'.format(
+                    type=mime_type, ext=ext, jid=entity_jid.full()))
         try:
-            type_ = unicode(photo_elt.elements(NS_VCARD, 'TYPE').next())
+            buf = str(photo_elt.elements(NS_VCARD, 'BINVAL').next())
         except StopIteration:
-            type_ = None
-        else:
-            if type_ and type_ not in ("image/gif", "image/jpeg", "image/png"):
-                # TODO: handle other image formats (svg?)
-                log.warning(u"following avatar image format is not handled: {type} [{jid}]".format(
-                    type=type_, jid=target.full()))
-                return
-            log.debug(u'Photo of type {type} found [{jid}]'.format(
-                    type=type_, jid=target.full()))
-        try:
-            bin_elt = photo_elt.elements(NS_VCARD, 'BINVAL').next()
-        except StopIteration:
-            return
-        buf = str(bin_elt)
+            log.warning(u"BINVAL element not found")
+            raise Failure(exceptions.NotFound())
         if not buf:
-            log.warning(u"empty avatar for {jid}".format(jid=target.full()))
-            return
+            log.warning(u"empty avatar for {jid}".format(jid=entity_jid.full()))
+            raise Failure(exceptions.NotFound())
         log.debug(_(u'Decoding binary'))
         decoded = b64decode(buf)
+        del buf
         image_hash = sha1(decoded).hexdigest()
-        self.saveAvatarFile(decoded, image_hash)
+        with client.cache.cacheData(
+            PLUGIN_INFO['import_name'],
+            image_hash,
+            mime_type,
+            # we keep in cache for 1 year
+            MAX_AGE
+            ) as f:
+            f.write(decoded)
         return image_hash
 
     @defer.inlineCallbacks
-    def vCard2Dict(self, client, vcard, target):
+    def vCard2Dict(self, client, vcard, entity_jid):
         """Convert a VCard to a dict, and save binaries"""
-        log.debug(_("parsing vcard"))
-        dictionary = {}
+        log.debug((u"parsing vcard"))
+        vcard_dict = {}
 
         for elem in vcard.elements():
             if elem.name == 'FN':
-                dictionary['fullname'] = unicode(elem)
+                vcard_dict['fullname'] = unicode(elem)
             elif elem.name == 'NICKNAME':
-                dictionary['nick'] = unicode(elem)
-                self.updateCache(client, target, 'nick', dictionary['nick'])
+                vcard_dict['nick'] = unicode(elem)
+                self.updateCache(client, entity_jid, 'nick', vcard_dict['nick'])
             elif elem.name == 'URL':
-                dictionary['website'] = unicode(elem)
+                vcard_dict['website'] = unicode(elem)
             elif elem.name == 'EMAIL':
-                dictionary['email'] = unicode(elem)
+                vcard_dict['email'] = unicode(elem)
             elif elem.name == 'BDAY':
-                dictionary['birthday'] = unicode(elem)
+                vcard_dict['birthday'] = unicode(elem)
             elif elem.name == 'PHOTO':
                 # TODO: handle EXTVAL
-                avatar_hash = yield threads.deferToThread(self.savePhoto, elem, target)
-                if avatar_hash is None: # can happen e.g. in case of empty photo elem
-                    continue
-                dictionary['avatar'] = avatar_hash
-                self.updateCache(client, target, 'avatar', dictionary['avatar'])
+                try:
+                    avatar_hash = yield threads.deferToThread(
+                        self.savePhoto, client, elem, entity_jid)
+                except (exceptions.DataError, exceptions.NotFound) as e:
+                    avatar_hash = ''
+                    vcard_dict['avatar'] = avatar_hash
+                except Exception as e:
+                    log.error(u"avatar saving error: {}".format(e))
+                    avatar_hash = None
+                else:
+                    vcard_dict['avatar'] = avatar_hash
+                self.updateCache(client, entity_jid, 'avatar', avatar_hash)
             else:
-                log.debug(_('FIXME: [%s] VCard tag is not managed yet') % elem.name)
+                log.debug(u'FIXME: [{}] VCard tag is not managed yet'.format(elem.name))
 
-        # if a data in cache doesn't exist anymore, we need to reset it
-        # so we check CACHED_DATA no gotten (i.e. not in dictionary keys)
+        # if a data in cache doesn't exist anymore, we need to delete it
+        # so we check CACHED_DATA no gotten (i.e. not in vcard_dict keys)
         # and we reset them
-        for datum in CACHED_DATA.difference(dictionary.keys()):
-            log.debug(u"reseting vcard datum [{datum}] for {entity}".format(datum=datum, entity=target.full()))
-            self.updateCache(client, target, datum, '')
+        for datum in CACHED_DATA.difference(vcard_dict.keys()):
+            log.debug(u"reseting vcard datum [{datum}] for {entity}".format(datum=datum, entity=entity_jid.full()))
+            self.updateCache(client, entity_jid, datum, None)
 
-        defer.returnValue(dictionary)
+        defer.returnValue(vcard_dict)
 
-    def _getCardCb(self, iq_elt, to_jid, client):
+    def _vCardCb(self, iq_elt, to_jid, client):
         """Called after the first get IQ"""
         log.debug(_("VCard found"))
 
@@ -286,71 +306,89 @@
         d = self.vCard2Dict(client, vcard_elt, from_jid)
         return d
 
-    def _getCardEb(self, failure_, to_jid, client):
+    def _vCardEb(self, failure_, to_jid, client):
         """Called when something is wrong with registration"""
         log.warning(u"Can't get vCard for {jid}: {failure}".format(jid=to_jid.full, failure=failure_))
-        self.updateCache(client, to_jid, "avatar", '')
+        self.updateCache(client, to_jid, "avatar", None)
 
-    def _getCard(self, target_s, profile_key=C.PROF_KEY_NONE):
-        client = self.host.getClient(profile_key)
-        return self.getCard(client, jid.JID(target_s))
-
-    def getCard(self, client, target):
+    def getCard(self, client, entity_jid):
         """Ask server for VCard
 
-        @param target(jid.JID): jid from which we want the VCard
+        @param entity_jid(jid.JID): jid from which we want the VCard
         @result: id to retrieve the profile
         """
-        target_bare = target.userhostJID()
-        to_jid = target if self.isRoom(client, target_bare) else target_bare
-        log.debug(_(u"Asking for %s's VCard") % to_jid.userhost())
+        entity_jid = self.getBareOrFull(client, entity_jid)
+        log.debug(u"Asking for {}'s VCard".format(entity_jid.full()))
         reg_request = client.IQ('get')
         reg_request["from"] = client.jid.full()
-        reg_request["to"] = to_jid.full()
+        reg_request["to"] = entity_jid.full()
         reg_request.addElement('vCard', NS_VCARD)
-        d = reg_request.send(to_jid.full()).addCallbacks(self._getCardCb, self._getCardEb, callbackArgs=[to_jid, client], errbackArgs=[to_jid, client])
+        d = reg_request.send(entity_jid.full()).addCallbacks(self._vCardCb, self._vCardEb, callbackArgs=[entity_jid, client], errbackArgs=[entity_jid, client])
+        return d
+
+    def _getCardCb(self, dummy, client, entity):
+        try:
+            return client._cache_0054[entity.full()]['avatar']
+        except KeyError:
+            raise Failure(exceptions.NotFound())
+
+    def _getAvatar(self, entity, cache_only, hash_only, profile):
+        client = self.host.getClient(profile)
+        d = self.getAvatar(client, jid.JID(entity))
+        d.addErrback(lambda dummy: '')
+
         return d
 
-    def getAvatarFile(self, avatar_hash):
-        """Give the full path of avatar from hash
-        @param avatar_hash(unicode): SHA1 hash
-        @return(unicode): full_path or empty string if avatar_hash is empty
-            or if avatar is not found in cache
+    def getAvatar(self, client, entity, cache_only=True, hash_only=False):
+        """get avatar full path or hash
+
+        if avatar is not in local cache, it will be requested to the server
+        @param entity(jid.JID): entity to get avatar from
+        @param cache_only(bool): if False, will request vCard if avatar is
+            not in cache
+        @param hash_only(bool): if True only return hash, not full path
+        @raise exceptions.NotFound: no avatar found
         """
-        if not avatar_hash:
-            return ""
-        filename = self.avatar_path + '/' + avatar_hash
-        if not os.path.exists(filename):
-            log.error(_(u"Asking for an uncached avatar [%s]") % avatar_hash)
-            return ""
-        return filename
+        entity = self.getBareOrFull(client, entity)
+        full_path = None
 
-    def _getAvatar(self, entity, profile):
-        client = self.host.getClient(profile)
-        return self.getAvatar(client, jid.JID(entity))
-
-    def _getAvatarGotCard(self, dummy, client, entity):
         try:
-            self.cache[client.profile][entity.full()]['avatar']
+            # we first check if we have avatar in cache
+            avatar_hash = client._cache_0054[entity.full()]['avatar']
+            if avatar_hash:
+                # avatar is known and exists
+                full_path = client.cache.getFilePath(avatar_hash)
+                if full_path is None:
+                    # cache file is not available (probably expired)
+                    raise KeyError
+            else:
+                # avatar has already been checked but it is not set
+                full_path = u''
         except KeyError:
-            return ""
+            # avatar is not in cache
+            if cache_only:
+                return defer.fail(Failure(exceptions.NotFound()))
+            # we request vCard to get avatar
+            d = self.getCard(client, entity)
+            d.addCallback(self._getCardCb, client, entity)
+        else:
+            # avatar is in cache, we can return hash
+            d = defer.succeed(avatar_hash)
 
-    def getAvatar(self, client, entity):
-        try:
-            avatar_hash = self.cache[client.profile][entity.full()]['avatar']
-        except KeyError:
-            d = self.getCard(client, entity)
-            d.addCallback(self._getAvatarGotCard, client, entity)
-        else:
-            d = defer.succeed(avatar_hash)
-        d.addCallback(self.getAvatarFile)
+        if not hash_only:
+            # full path is requested
+            if full_path is None:
+                d.addCallback(client.cache.getFilePath)
+            else:
+                d.addCallback(lambda dummy: full_path)
         return d
 
-    def _buildSetAvatar(self, vcard_set, filepath):
+    def _buildSetAvatar(self, client, vcard_set, file_path):
+        # XXX: this method is executed in a separate thread
         try:
-            img = Image.open(filepath)
+            img = Image.open(file_path)
         except IOError:
-            return Failure(exceptions.DataError("Can't open image"))
+            return Failure(exceptions.DataError(u"Can't open image"))
 
         if img.size != AVATAR_DIM:
             img.thumbnail(AVATAR_DIM, Image.ANTIALIAS)
@@ -372,24 +410,34 @@
         photo_elt = vcard_elt.addElement('PHOTO')
         photo_elt.addElement('TYPE', content='image/png')
         photo_elt.addElement('BINVAL', content=b64encode(img_buf.getvalue()))
-        img_hash = sha1(img_buf.getvalue()).hexdigest()
-        self.saveAvatarFile(img_buf.getvalue(), img_hash)
-        return (vcard_set, img_hash)
+        image_hash = sha1(img_buf.getvalue()).hexdigest()
+        with client.cache.cacheData(
+            PLUGIN_INFO['import_name'],
+            image_hash,
+            "image/png",
+            MAX_AGE
+            ) as f:
+            f.write(img_buf.getvalue())
+        return vcard_set, image_hash
 
-    def setAvatar(self, filepath, profile_key=C.PROF_KEY_NONE):
+    def _setAvatar(self, file_path, profile_key=C.PROF_KEY_NONE):
+        client = self.host.getClient(profile_key)
+        return self.setAvatar(client, file_path)
+
+    def setAvatar(self, client, file_path):
         """Set avatar of the profile
-        @param filepath: path of the image of the avatar"""
+
+        @param file_path: path of the image of the avatar
+        """
         #TODO: This is a temporary way of setting the avatar, as other VCard information is not managed.
         #      A proper full VCard management should be done (and more generaly a public/private profile)
-        client = self.host.getClient(profile_key)
-
-        vcard_set = IQ(client.xmlstream, 'set')
-        d = threads.deferToThread(self._buildSetAvatar, vcard_set, filepath)
+        vcard_set = client.IQ()
+        d = threads.deferToThread(self._buildSetAvatar, client, vcard_set, file_path)
 
         def elementBuilt(result):
             """Called once the image is at the right size/format, and the vcard set element is build"""
-            set_avatar_elt, img_hash = result
-            self.updateCache(client, client.jid.userhostJID(), 'avatar', img_hash)
+            set_avatar_elt, image_hash = result
+            self.updateCache(client, client.jid.userhostJID(), 'avatar', image_hash)
             return set_avatar_elt.send().addCallback(lambda ignore: client.presence.available()) # FIXME: should send the current presence, not always "available" !
 
         d.addCallback(elementBuilt)
@@ -413,15 +461,24 @@
     def getDiscoItems(self, requestor, target, nodeIdentifier=''):
         return []
 
+    def _checkAvatarHash(self, dummy, client, entity, given_hash):
+        """check that hash in cash (i.e. computed hash) is the same as given one"""
+        # XXX: if they differ, the avater will be requested on each connection
+        # TODO: try to avoid re-requesting avatar in this case
+        computed_hash = self.plugin_parent.getCache(client, entity, 'avatar')
+        if computed_hash != given_hash:
+            log.warning(u"computed hash differs from given hash for {entity}:\n"
+                "computed: {computed}\ngiven: {given}".format(
+                entity=entity, computed=computed_hash, given=given_hash))
+
     def update(self, presence):
         """Called on <presence/> stanza with vcard data
 
         Check for avatar information, and get VCard if needed
         @param presend(domish.Element): <presence/> stanza
         """
-        from_jid = jid.JID(presence['from'])
-        if from_jid.resource and not self.plugin_parent.isRoom(self.parent, from_jid):
-            from_jid = from_jid.userhostJID()
+        client = self.parent
+        entity_jid = self.plugin_parent.getBareOrFull(client, jid.JID(presence['from']))
         #FIXME: wokkel's data_form should be used here
         try:
             x_elt = presence.elements(NS_VCARD_UPDATE, 'x').next()
@@ -433,22 +490,35 @@
         except StopIteration:
             return
 
-        hash_ = str(photo_elt)
-        if not hash_:
-            return
-        old_avatar = self.plugin_parent.getCache(self.parent, from_jid, 'avatar')
-        filename = self.plugin_parent._getFilename(hash_)
-        if not old_avatar or old_avatar != hash_:
-            if os.path.exists(filename):
-                log.debug(u"New avatar found for [{}], it's already in cache, we use it".format(from_jid.full()))
-                self.plugin_parent.updateCache(self.parent, from_jid, 'avatar', hash_)
+        hash_ = unicode(photo_elt).strip()
+        if hash_ == C.HASH_SHA1_EMPTY:
+            hash_ = u''
+        old_avatar = self.plugin_parent.getCache(client, entity_jid, 'avatar')
+
+        if old_avatar == hash_:
+            # no change, we can return...
+            if hash_:
+                # ...but we double check that avatar is in cache
+                file_path = client.cache.getFilePath(hash_)
+                if file_path is None:
+                    log.error(u"Avatar for [{}] should be in cache but it is not! We get it".format(entity_jid.full()))
+                    self.plugin_parent.getCard(client, entity_jid)
             else:
-                log.debug(u'New avatar found for [{}], requesting vcard'.format(from_jid.full()))
-                self.plugin_parent.getCard(self.parent, from_jid)
+                log.debug(u"avatar for {} already in cache".format(entity_jid.full()))
+            return
+
+        if not hash_:
+            # the avatar has been removed
+            # XXX: we use empty string instead of None to indicate that we took avatar
+            #      but it is empty on purpose
+            self.plugin_parent.updateCache(client, entity_jid, 'avatar', '')
+            return
+
+        file_path = client.cache.getFilePath(hash_)
+        if file_path is not None:
+            log.debug(u"New avatar found for [{}], it's already in cache, we use it".format(entity_jid.full()))
+            self.plugin_parent.updateCache(client, entity_jid, 'avatar', hash_)
         else:
-            if os.path.exists(filename):
-                log.debug(u"avatar for {} already in cache".format(from_jid.full()))
-            else:
-                log.error(u"Avatar for [{}] should be in cache but it is not ! We get it".format(from_jid.full()))
-                self.plugin_parent.getCard(self.parent, from_jid)
-
+            log.debug(u'New avatar found for [{}], requesting vcard'.format(entity_jid.full()))
+            d = self.plugin_parent.getCard(client, entity_jid)
+            d.addCallback(self._checkAvatarHash, client, entity_jid, hash_)