slidge 0.2.0a9__py3-none-any.whl → 0.2.0a10__py3-none-any.whl

slidge/core/{gateway → dispatcher}/search.py

@@ -3,13 +3,15 @@ from typing import TYPE_CHECKING
 from slixmpp import JID, CoroutineCallback, Iq, StanzaPath
 from slixmpp.exceptions import XMPPError
 
+from .util import DispatcherMixin, exceptions_to_xmpp_errors
+
 if TYPE_CHECKING:
-    from .base import BaseGateway
+    from slidge.core.gateway import BaseGateway
 
 
-class Search:
+class SearchMixin(DispatcherMixin):
     def __init__(self, xmpp: "BaseGateway"):
-        self.xmpp = xmpp
+        super().__init__(xmpp)
 
         xmpp["xep_0055"].api.register(self.search_get_form, "search_get_form")
         xmpp["xep_0055"].api.register(self._search_query, "search_query")
@@ -45,13 +47,9 @@ class Search:
         """
         Handles a search request
         """
-        user = self.xmpp.store.users.get(ifrom)
-        if user is None:
-            raise XMPPError(text="Search is only allowed for registered users")
+        session = await self._get_session(iq)
 
-        result = await self.xmpp.get_session_from_stanza(iq).on_search(
-            iq["search"]["form"].get_values()
-        )
+        result = await session.on_search(iq["search"]["form"].get_values())
 
         if not result:
             raise XMPPError("item-not-found", text="Nothing was found")
@@ -64,19 +62,17 @@ class Search:
             form.add_item(item)
         return reply
 
+    @exceptions_to_xmpp_errors
     async def _handle_gateway_iq(self, iq: Iq):
         if iq.get_to() != self.xmpp.boundjid.bare:
             raise XMPPError("bad-request", "This can only be used on the component JID")
 
-        user = self.xmpp.store.users.get(iq.get_from())
-        if user is None:
-            raise XMPPError("not-authorized", "Register to the gateway first")
-
         if len(self.xmpp.SEARCH_FIELDS) > 1:
             raise XMPPError(
                 "feature-not-implemented", "Use jabber search for this gateway"
             )
 
+        session = await self._get_session(iq)
         field = self.xmpp.SEARCH_FIELDS[0]
 
         reply = iq.reply()
@@ -85,7 +81,6 @@ class Search:
             reply["gateway"]["prompt"] = field.label
         elif iq["type"] == "set":
             prompt = iq["gateway"]["prompt"]
-            session = self.xmpp.session_cls.from_user(user)
             result = await session.on_search({field.var: prompt})
             if result is None or not result.items:
                 raise XMPPError(

slidge/core/dispatcher/session_dispatcher.py

@@ -0,0 +1,84 @@
+import logging
+from typing import TYPE_CHECKING
+
+from slixmpp import Message
+from slixmpp.exceptions import IqError
+from slixmpp.plugins.xep_0084.stanza import Info
+
+from ..session import BaseSession
+from .caps import CapsMixin
+from .disco import DiscoMixin
+from .message import MessageMixin
+from .muc import MucMixin
+from .presence import PresenceHandlerMixin
+from .registration import RegistrationMixin
+from .search import SearchMixin
+from .util import exceptions_to_xmpp_errors
+from .vcard import VCardMixin
+
+if TYPE_CHECKING:
+    from slidge.core.gateway import BaseGateway
+
+
+class SessionDispatcher(
+    CapsMixin,
+    DiscoMixin,
+    RegistrationMixin,
+    MessageMixin,
+    MucMixin,
+    PresenceHandlerMixin,
+    SearchMixin,
+    VCardMixin,
+):
+    def __init__(self, xmpp: "BaseGateway"):
+        super().__init__(xmpp)
+        xmpp.add_event_handler(
+            "avatar_metadata_publish", self.on_avatar_metadata_publish
+        )
+
+    @exceptions_to_xmpp_errors
+    async def on_avatar_metadata_publish(self, m: Message):
+        session = await self._get_session(m, timeout=None)
+        if not session.user.preferences.get("sync_avatar", False):
+            session.log.debug("User does not want to sync their avatar")
+            return
+        info = m["pubsub_event"]["items"]["item"]["avatar_metadata"]["info"]
+
+        await self.on_avatar_metadata_info(session, info)
+
+    async def on_avatar_metadata_info(self, session: BaseSession, info: Info):
+        hash_ = info["id"]
+
+        if session.user.avatar_hash == hash_:
+            session.log.debug("We already know this avatar hash")
+            return
+        self.xmpp.store.users.set_avatar_hash(session.user_pk, None)
+
+        if hash_:
+            try:
+                iq = await self.xmpp.plugin["xep_0084"].retrieve_avatar(
+                    session.user_jid, hash_, ifrom=self.xmpp.boundjid.bare
+                )
+            except IqError as e:
+                session.log.warning("Could not fetch the user's avatar: %s", e)
+                return
+            bytes_ = iq["pubsub"]["items"]["item"]["avatar_data"]["value"]
+            type_ = info["type"]
+            height = info["height"]
+            width = info["width"]
+        else:
+            bytes_ = type_ = height = width = hash_ = None
+        try:
+            await session.on_avatar(bytes_, hash_, type_, width, height)
+        except NotImplementedError:
+            pass
+        except Exception as e:
+            # If something goes wrong here, replying an error stanza will to the
+            # avatar update will likely not show in most clients, so let's send
+            # a normal message from the component to the user.
+            session.send_gateway_message(
+                f"Something went wrong trying to set your avatar: {e!r}"
+            )
+
+
+log = logging.getLogger(__name__)

slidge/core/dispatcher/util.py

@@ -0,0 +1,174 @@
+import logging
+from functools import wraps
+from typing import TYPE_CHECKING, Any, Awaitable, Callable, TypeVar
+
+from slixmpp import JID, Iq, Message, Presence
+from slixmpp.exceptions import XMPPError
+from slixmpp.xmlstream import StanzaBase
+
+from ...util.types import Recipient, RecipientType
+from ..session import BaseSession
+
+if TYPE_CHECKING:
+    from slidge import BaseGateway
+    from slidge.group import LegacyMUC
+
+
+class Ignore(BaseException):
+    pass
+
+
+class DispatcherMixin:
+    def __init__(self, xmpp: "BaseGateway"):
+        self.xmpp = xmpp
+
+    async def _get_session(
+        self,
+        stanza: Message | Presence | Iq,
+        timeout: int | None = 10,
+        wait_for_ready=True,
+        logged=False,
+    ) -> BaseSession:
+        xmpp = self.xmpp
+        if stanza.get_from().server == xmpp.boundjid.bare:
+            log.debug("Ignoring echo")
+            raise Ignore
+        if (
+            isinstance(stanza, Message)
+            and stanza.get_type() == "chat"
+            and stanza.get_to() == xmpp.boundjid.bare
+        ):
+            log.debug("Ignoring message to component")
+            raise Ignore
+        session = await self._get_session_from_jid(
+            stanza.get_from(), timeout, wait_for_ready, logged
+        )
+        if isinstance(stanza, Message) and _ignore(session, stanza):
+            raise Ignore
+        return session
+
+    async def _get_session_from_jid(
+        self,
+        jid: JID,
+        timeout: int | None = 10,
+        wait_for_ready=True,
+        logged=False,
+    ) -> BaseSession:
+        session = self.xmpp.get_session_from_jid(jid)
+        if session is None:
+            raise XMPPError("registration-required")
+        if logged:
+            session.raise_if_not_logged()
+        if wait_for_ready:
+            await session.wait_for_ready(timeout)
+        return session
+
+    async def get_muc_from_stanza(self, iq: Iq | Message | Presence) -> "LegacyMUC":
+        ito = iq.get_to()
+        if ito == self.xmpp.boundjid.bare:
+            raise XMPPError("bad-request", text="This is only handled for MUCs")
+
+        session = await self._get_session(iq, logged=True)
+        muc = await session.bookmarks.by_jid(ito)
+        return muc
+
+    def _xmpp_msg_id_to_legacy(self, session: "BaseSession", xmpp_id: str):
+        sent = self.xmpp.store.sent.get_legacy_id(session.user_pk, xmpp_id)
+        if sent is not None:
+            return self.xmpp.LEGACY_MSG_ID_TYPE(sent)
+
+        multi = self.xmpp.store.multi.get_legacy_id(session.user_pk, xmpp_id)
+        if multi:
+            return self.xmpp.LEGACY_MSG_ID_TYPE(multi)
+
+        try:
+            return session.xmpp_to_legacy_msg_id(xmpp_id)
+        except XMPPError:
+            raise
+        except Exception as e:
+            log.debug("Couldn't convert xmpp msg ID to legacy ID.", exc_info=e)
+            raise XMPPError(
+                "internal-server-error", "Couldn't convert xmpp msg ID to legacy ID."
+            )
+
+    async def _get_session_entity_thread(
+        self, msg: Message
+    ) -> tuple["BaseSession", Recipient, int | str]:
+        session = await self._get_session(msg)
+        e: Recipient = await _get_entity(session, msg)
+        legacy_thread = await _xmpp_to_legacy_thread(session, msg, e)
+        return session, e, legacy_thread
+
+
+def _ignore(session: "BaseSession", msg: Message):
+    i = msg.get_id()
+    if i.startswith("slidge-carbon-"):
+        return True
+    if i not in session.ignore_messages:
+        return False
+    session.log.debug("Ignored sent carbon: %s", i)
+    session.ignore_messages.remove(i)
+    return True
+
+
+async def _xmpp_to_legacy_thread(
+    session: "BaseSession", msg: Message, recipient: RecipientType
+):
+    xmpp_thread = msg["thread"]
+    if not xmpp_thread:
+        return
+
+    if session.MESSAGE_IDS_ARE_THREAD_IDS:
+        return session.xmpp.store.sent.get_legacy_thread(session.user_pk, xmpp_thread)
+
+    async with session.thread_creation_lock:
+        legacy_thread_str = session.xmpp.store.sent.get_legacy_thread(
+            session.user_pk, xmpp_thread
+        )
+        if legacy_thread_str is None:
+            legacy_thread = str(await recipient.create_thread(xmpp_thread))
+            session.xmpp.store.sent.set_thread(
+                session.user_pk, xmpp_thread, legacy_thread
+            )
+    return session.xmpp.LEGACY_MSG_ID_TYPE(legacy_thread)
+
+
+async def _get_entity(session: "BaseSession", m: Message) -> RecipientType:
+    session.raise_if_not_logged()
+    if m.get_type() == "groupchat":
+        muc = await session.bookmarks.by_jid(m.get_to())
+        r = m.get_from().resource
+        if r not in muc.get_user_resources():
+            session.create_task(muc.kick_resource(r))
+            raise XMPPError("not-acceptable", "You are not connected to this chat")
+        return muc
+    else:
+        return await session.contacts.by_jid(m.get_to())
+
+
+StanzaType = TypeVar("StanzaType", bound=StanzaBase)
+HandlerType = Callable[[Any, StanzaType], Awaitable[None]]
+
+
+def exceptions_to_xmpp_errors(cb: HandlerType) -> HandlerType:
+    @wraps(cb)
+    async def wrapped(*args):
+        try:
+            await cb(*args)
+        except Ignore:
+            pass
+        except XMPPError:
+            raise
+        except NotImplementedError:
+            log.debug("NotImplementedError raised in %s", cb)
+            raise XMPPError(
+                "feature-not-implemented", "Not implemented by the legacy module"
+            )
+        except Exception as e:
+            log.error("Failed to handle incoming stanza: %s", args, exc_info=e)
+            raise XMPPError("internal-server-error", str(e))
+
+    return wrapped
+
+
+log = logging.getLogger(__name__)

slidge/core/{gateway/vcard_temp.py → dispatcher/vcard.py}

@@ -1,5 +1,4 @@
 from copy import copy
-from typing import TYPE_CHECKING
 
 from slixmpp import CoroutineCallback, Iq, StanzaPath, register_stanza_plugin
 from slixmpp.exceptions import XMPPError
@@ -9,21 +8,23 @@ from slixmpp.plugins.xep_0292.stanza import NS as VCard4NS
 from ...contact import LegacyContact
 from ...core.session import BaseSession
 from ...group import LegacyParticipant
+from .util import DispatcherMixin, exceptions_to_xmpp_errors
 
-if TYPE_CHECKING:
-    from .base import BaseGateway
 
-
-class VCardTemp:
-    def __init__(self, xmpp: "BaseGateway"):
-        self.xmpp = xmpp
-        # remove slixmpp's default handler to replace with our own
-        self.xmpp.remove_handler("VCardTemp")
+class VCardMixin(DispatcherMixin):
+    def __init__(self, xmpp):
+        super().__init__(xmpp)
+        xmpp.register_handler(
+            CoroutineCallback(
+                "get_vcard", StanzaPath("iq@type=get/vcard"), self.on_get_vcard
+            )
+        )
+        xmpp.remove_handler("VCardTemp")
         xmpp.register_handler(
             CoroutineCallback(
                 "VCardTemp",
                 StanzaPath("iq/vcard_temp"),
-                self.__handler,  # type:ignore
+                self.__vcard_temp_handler,
             )
         )
         # TODO: MR to slixmpp adding this to XEP-0084
@@ -32,7 +33,20 @@ class VCardTemp:
             MetaData,
         )
 
-    async def __handler(self, iq: Iq):
+    @exceptions_to_xmpp_errors
+    async def on_get_vcard(self, iq: Iq):
+        session = await self._get_session(iq, logged=True)
+        contact = await session.contacts.by_jid(iq.get_to())
+        vcard = await contact.get_vcard()
+        reply = iq.reply()
+        if vcard:
+            reply.append(vcard)
+        else:
+            reply.enable("vcard")
+        reply.send()
+
+    @exceptions_to_xmpp_errors
+    async def __vcard_temp_handler(self, iq: Iq):
         if iq["type"] == "get":
             return await self.__handle_get_vcard_temp(iq)
 
@@ -105,7 +119,7 @@ class VCardTemp:
         reply.send()
 
     async def __handle_set_vcard_temp(self, iq: Iq):
-        muc = await self.xmpp.get_muc_from_stanza(iq)
+        muc = await self.get_muc_from_stanza(iq)
         to = iq.get_to()
 
         if to.resource:

slidge/core/{gateway/base.py → gateway.py}

@@ -8,16 +8,7 @@ import re
 import tempfile
 from copy import copy
 from datetime import datetime
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    Callable,
-    Collection,
-    Mapping,
-    Optional,
-    Sequence,
-    Union,
-)
+from typing import TYPE_CHECKING, Any, Callable, Mapping, Optional, Sequence, Union
 
 import aiohttp
 import qrcode
@@ -27,40 +18,30 @@ from slixmpp.plugins.xep_0060.stanza import OwnerAffiliation
 from slixmpp.types import MessageTypes
 from slixmpp.xmlstream.xmlstream import NotConnectedError
 
-from ... import command  # noqa: F401
-from ...command.adhoc import AdhocProvider
-from ...command.admin import Exec
-from ...command.base import Command, FormField
-from ...command.chat_command import ChatCommandProvider
-from ...command.register import RegistrationType
-from ...db import GatewayUser, SlidgeStore
-from ...db.avatar import avatar_cache
-from ...slixfix.roster import RosterBackend
-from ...util import ABCSubclassableOnceAtMost
-from ...util.types import AvatarType, MessageOrPresenceTypeVar
-from ...util.util import timeit
-from .. import config
-from ..mixins import MessageMixin
-from ..pubsub import PubSubComponent
-from ..session import BaseSession
-from .caps import Caps
-from .delivery_receipt import DeliveryReceipt
-from .disco import Disco
-from .mam import Mam
-from .muc_admin import MucAdmin
-from .ping import Ping
-from .presence import PresenceHandlerMixin
-from .registration import Registration
-from .search import Search
-from .session_dispatcher import SessionDispatcher
-from .vcard_temp import VCardTemp
+from slidge import command  # noqa: F401
+from slidge.command.adhoc import AdhocProvider
+from slidge.command.admin import Exec
+from slidge.command.base import Command, FormField
+from slidge.command.chat_command import ChatCommandProvider
+from slidge.command.register import RegistrationType
+from slidge.core import config
+from slidge.core.dispatcher.session_dispatcher import SessionDispatcher
+from slidge.core.mixins import MessageMixin
+from slidge.core.pubsub import PubSubComponent
+from slidge.core.session import BaseSession
+from slidge.db import GatewayUser, SlidgeStore
+from slidge.db.avatar import avatar_cache
+from slidge.slixfix.delivery_receipt import DeliveryReceipt
+from slidge.slixfix.roster import RosterBackend
+from slidge.util import ABCSubclassableOnceAtMost
+from slidge.util.types import AvatarType, MessageOrPresenceTypeVar
+from slidge.util.util import timeit
 
 if TYPE_CHECKING:
-    from ...group.room import LegacyMUC
+    pass
 
 
 class BaseGateway(
-    PresenceHandlerMixin,
     ComponentXMPP,
     MessageMixin,
     metaclass=ABCSubclassableOnceAtMost,
@@ -118,7 +99,7 @@ class BaseGateway(
     Path, bytes or URL used by the component as an avatar.
     """
 
-    REGISTRATION_FIELDS: Collection[FormField] = [
+    REGISTRATION_FIELDS: Sequence[FormField] = [
         FormField(var="username", label="User name", required=True),
         FormField(var="password", label="Password", required=True, private=True),
     ]
@@ -315,7 +296,7 @@ class BaseGateway(
         self.session_cls: BaseSession = BaseSession.get_unique_subclass()
         self.session_cls.xmpp = self
 
-        from ...group.room import LegacyMUC
+        from ..group.room import LegacyMUC
 
         LegacyMUC.get_self_or_unique_subclass().xmpp = self
 
@@ -328,6 +309,7 @@ class BaseGateway(
 
         self.register_plugins()
         self.__register_slixmpp_events()
+        self.__register_slixmpp_api()
         self.roster.set_backend(RosterBackend(self))
 
         self.register_plugin("pubsub", {"component_name": self.COMPONENT_NAME})
@@ -355,21 +337,11 @@ class BaseGateway(
         # why does mypy need these type annotations? no idea
         self.__adhoc_handler: AdhocProvider = AdhocProvider(self)
         self.__chat_commands_handler: ChatCommandProvider = ChatCommandProvider(self)
-        self.__disco_handler = Disco(self)
-
-        self.__ping_handler = Ping(self)
-        self.__mam_handler = Mam(self)
-        self.__search_handler = Search(self)
-        self.__caps_handler = Caps(self)
-        self.__vcard_temp_handler = VCardTemp(self)
-        self.__muc_admin_handler = MucAdmin(self)
-        self.__registration = Registration(self)
+
         self.__dispatcher = SessionDispatcher(self)
 
         self.__register_commands()
 
-        self.__mam_cleanup_task = self.loop.create_task(self.__mam_cleanup())
-
         MessageMixin.__init__(self)  # ComponentXMPP does not call super().__init__()
 
     async def __set_http(self):
@@ -378,13 +350,6 @@ class BaseGateway(
             return
         avatar_cache.http = self.http
 
-    async def __mam_cleanup(self):
-        if not config.MAM_MAX_DAYS:
-            return
-        while True:
-            await asyncio.sleep(3600 * 6)
-            self.store.mam.nuke_older_than(config.MAM_MAX_DAYS)
-
     def __register_commands(self):
         for cls in Command.subclasses:
             if any(x is NotImplemented for x in [cls.CHAT_COMMAND, cls.NODE, cls.NAME]):
@@ -421,40 +386,27 @@ class BaseGateway(
             loop.stop()
 
     def __register_slixmpp_events(self):
+        self.del_event_handler("presence_subscribe", self._handle_subscribe)
+        self.del_event_handler("presence_unsubscribe", self._handle_unsubscribe)
+        self.del_event_handler("presence_subscribed", self._handle_subscribed)
+        self.del_event_handler("presence_unsubscribed", self._handle_unsubscribed)
+        self.del_event_handler(
+            "roster_subscription_request", self._handle_new_subscription
+        )
+        self.del_event_handler("presence_probe", self._handle_probe)
         self.add_event_handler("session_start", self.__on_session_start)
         self.add_event_handler("disconnected", self.connect)
-        self.add_event_handler("user_register", self._on_user_register)
-        self.add_event_handler("user_unregister", self._on_user_unregister)
-        self.add_event_handler("groupchat_message_error", self.__on_group_chat_error)
+
+    def __register_slixmpp_api(self) -> None:
+        self.plugin["xep_0231"].api.register(self.store.bob.get_bob, "get_bob")
+        self.plugin["xep_0231"].api.register(self.store.bob.set_bob, "set_bob")
+        self.plugin["xep_0231"].api.register(self.store.bob.del_bob, "del_bob")
 
     @property  # type: ignore
     def jid(self):
         # Override to avoid slixmpp deprecation warnings.
         return self.boundjid
 
-    async def __on_group_chat_error(self, msg: Message):
-        condition = msg["error"].get_condition()
-        if condition not in KICKABLE_ERRORS:
-            return
-
-        try:
-            muc = await self.get_muc_from_stanza(msg)
-        except XMPPError as e:
-            log.debug("Not removing resource", exc_info=e)
-            return
-        mfrom = msg.get_from()
-        resource = mfrom.resource
-        try:
-            muc.remove_user_resource(resource)
-        except KeyError:
-            # this actually happens quite frequently on for both beagle and monal
-            # (not sure why?), but is of no consequence
-            log.debug("%s was not in the resources of %s", resource, muc)
-        else:
-            log.info(
-                "Removed %s from the resources of %s because of error", resource, muc
-            )
-
     async def __on_session_start(self, event):
         log.debug("Gateway session start: %s", event)
 
@@ -490,7 +442,7 @@ class BaseGateway(
                 pto=user.jid.bare, ptype="probe"
             )  # ensure we get all resources for user
             session = self.session_cls.from_user(user)
-            session.create_task(self.__login_wrap(session))
+            session.create_task(self.login_wrap(session))
             if cached_avatar is not None:
                 await self.pubsub.broadcast_avatar(
                     self.boundjid.bare, session.user_jid, cached_avatar
@@ -551,7 +503,7 @@ class BaseGateway(
             )
 
     @timeit
-    async def __login_wrap(self, session: "BaseSession"):
+    async def login_wrap(self, session: "BaseSession"):
         session.send_gateway_status("Logging in…", show="dnd")
         try:
             status = await session.login()
@@ -612,21 +564,6 @@ class BaseGateway(
         stanza.send()
         return stanza
 
-    async def _on_user_register(self, iq: Iq):
-        session = self.get_session_from_stanza(iq)
-        for jid in config.ADMINS:
-            self.send_message(
-                mto=jid,
-                mbody=f"{iq.get_from()} has registered",
-                mtype="chat",
-                mfrom=self.boundjid.bare,
-            )
-        session.send_gateway_message(self.WELCOME_MESSAGE)
-        await self.__login_wrap(session)
-
-    async def _on_user_unregister(self, iq: Iq):
-        await self.session_cls.kill_by_jid(iq.get_from())
-
     def raise_if_not_allowed_jid(self, jid: JID):
         if not self.jid_validator.match(jid.bare):
             raise XMPPError(
@@ -665,26 +602,6 @@ class BaseGateway(
         except XMPPError:
             pass
 
-    async def get_muc_from_stanza(self, iq: Union[Iq, Message]) -> "LegacyMUC":
-        ito = iq.get_to()
-
-        if ito == self.boundjid.bare:
-            raise XMPPError(
-                text="No MAM on the component itself, use a JID with a resource"
-            )
-
-        ifrom = iq.get_from()
-        user = self.store.users.get(ifrom)
-        if user is None:
-            raise XMPPError("registration-required")
-
-        session = self.get_session_from_user(user)
-        session.raise_if_not_logged()
-
-        muc = await session.bookmarks.by_jid(ito)
-
-        return muc
-
     def exception(self, exception: Exception):
         # """
         # Called when a task created by slixmpp's internal (eg, on slix events) raises an Exception.
@@ -719,7 +636,7 @@ class BaseGateway(
         async def w():
             session.cancel_all_tasks()
             await session.logout()
-            await self.__login_wrap(session)
+            await self.login_wrap(session)
 
         session.create_task(w())
 
@@ -949,20 +866,6 @@ class BaseGateway(
         return tasks
 
 
-KICKABLE_ERRORS = {
-    "gone",
-    "internal-server-error",
-    "item-not-found",
-    "jid-malformed",
-    "recipient-unavailable",
-    "redirect",
-    "remote-server-not-found",
-    "remote-server-timeout",
-    "service-unavailable",
-    "malformed error",
-}
-
-
 SLIXMPP_PLUGINS = [
     "link_preview",  # https://wiki.soprani.ca/CheogramApp/LinkPreviews
     "xep_0030",  # Service discovery
@@ -972,6 +875,7 @@ SLIXMPP_PLUGINS = [
     "xep_0055",  # Jabber search
     "xep_0059",  # Result Set Management
     "xep_0066",  # Out of Band Data
+    "xep_0071",  # XHTML-IM (for stickers and custom emojis maybe later)
     "xep_0077",  # In-band registration
     "xep_0084",  # User Avatar
     "xep_0085",  # Chat state notifications
@@ -984,6 +888,7 @@ SLIXMPP_PLUGINS = [
     "xep_0184",  # Message Delivery Receipts
     "xep_0199",  # XMPP Ping
     "xep_0221",  # Data Forms Media Element
+    "xep_0231",  # Bits of Binary (for stickers and custom emojis maybe later)
     "xep_0249",  # Direct MUC Invitations
     "xep_0264",  # Jingle Content Thumbnails
     "xep_0280",  # Carbons