plugin XEP-0033: implementation of the addressing feature:

- frontends pass the recipients in the extra parameter of sendMessage
    - backend checks if the target server supports the feature (this is not done yet by prosody plugin)
    - features and identities are cached per profile and server
    - messages are duplicated in history for now (TODO: redesign the database)
    - echos signals are also duplicated to the sender (FIXME)

src/memory/memory.py

@@ -756,49 +756,63 @@ class Memory(object):
         assert profile != "@NONE@"
         return self.storage.getHistory(jid.JID(from_jid), jid.JID(to_jid), limit, between, profile)
 
-    def addServerFeature(self, feature, profile):
+    def addServerFeature(self, feature, jid_, profile):
         """Add a feature discovered from server
         @param feature: string of the feature
-        @param profile: which profile is using this server ?"""
+        @param jid_: the jid of the target server
+        @param profile: which profile is asking this server ?"""
         if profile not in self.server_features:
-            self.server_features[profile] = []
-        self.server_features[profile].append(feature)
+            self.server_features[profile] = {}
+        features = self.server_features[profile].setdefault(jid_, [])
+        features.append(feature)
 
-    def addServerIdentity(self, category, type_, entity, profile):
+    def addServerIdentity(self, category, type_, entity, jid_, profile):
         """Add an identity discovered from server
         @param feature: string of the feature
-        @param profile: which profile is using this server ?"""
+        @param jid_: the jid of the target server
+        @param profile: which profile is asking this server ?"""
         if not profile in self.server_identities:
             self.server_identities[profile] = {}
-        if (category, type_) not in self.server_identities[profile]:
-            self.server_identities[profile][(category, type_)] = set()
-        self.server_identities[profile][(category, type_)].add(entity)
+        identities = self.server_identities[profile].setdefault(jid_, {})
+        if (category, type_) not in identities:
+            identities[(category, type_)] = set()
+        identities[(category, type_)].add(entity)
 
-    def getServerServiceEntities(self, category, type_, profile):
+    def getServerServiceEntities(self, category, type_, jid_=None, profile=None):
         """Return all available entities for a service"""
-        if profile in self.server_identities:
-            return self.server_identities[profile].get((category, type_), set())
+        if jid_ is None:
+            jid_ = self.host.getClientHostJid(profile)
+        if profile in self.server_identities and jid_ in self.server_identities[profile]:
+            return self.server_identities[profile][jid_].get((category, type_), set())
         else:
             return None
 
-    def getServerServiceEntity(self, category, type_, profile):
+    def getServerServiceEntity(self, category, type_, jid_=None, profile=None):
         """Helper method to get first available entity for a service"""
-        entities = self.getServerServiceEntities(category, type_, profile)
+        if jid_ is None:
+            jid_ = self.host.getClientHostJid(profile)
+        entities = self.getServerServiceEntities(category, type_, jid_, profile)
         if entities is None:
-            warning(_("Entities (%(category)s/%(type)s) not available, maybe they haven't been asked to server yet ?") % {"category": category,
-                                                                                                                          "type": type_})
+            warning(_("Entities (%(category)s/%(type)s) of %(server)s not available, maybe they haven't been asked yet?")
+                    % {"category": category, "type": type_, "server": jid_})
             return None
         else:
             return list(entities)[0] if entities else None
 
-    def hasServerFeature(self, feature, profile_key):
+    def hasServerFeature(self, feature, jid_=None, profile_key="@NONE@"):
         """Tell if the server of the profile has the required feature"""
         profile = self.getProfileName(profile_key)
         if not profile:
             error(_('Trying find server feature for a non-existant profile'))
-            return
+            return None
         assert profile in self.server_features
-        return feature in self.server_features[profile]
+        if jid_ is None:
+            jid_ = self.host.getClientHostJid(profile)
+        if jid_ in self.server_features[profile]:
+            return feature in self.server_features[profile][jid_]
+        else:
+            warning(_("Features of %s not available, maybe they haven't been asked yet?") % jid_)
+            return None
 
     def getLastResource(self, contact, profile_key):
         """Return the last resource used by a contact