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

slidge/core/dispatcher/muc/misc.py

@@ -0,0 +1,121 @@
+import logging
+
+from slixmpp import JID, CoroutineCallback, Iq, Message, Presence, StanzaPath
+from slixmpp.exceptions import XMPPError
+
+from ..util import DispatcherMixin, exceptions_to_xmpp_errors
+
+
+class MucMiscMixin(DispatcherMixin):
+    def __init__(self, xmpp):
+        super().__init__(xmpp)
+        xmpp.register_handler(
+            CoroutineCallback(
+                "ibr_remove", StanzaPath("/iq/register"), self.on_ibr_remove
+            )
+        )
+
+        xmpp.add_event_handler("groupchat_join", self.on_groupchat_join)
+        xmpp.add_event_handler(
+            "groupchat_direct_invite", self.on_groupchat_direct_invite
+        )
+        xmpp.add_event_handler("groupchat_subject", self.on_groupchat_subject)
+        xmpp.add_event_handler("groupchat_message_error", self.__on_group_chat_error)
+
+    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
+            )
+
+    @exceptions_to_xmpp_errors
+    async def on_ibr_remove(self, iq: Iq):
+        if iq.get_to() == self.xmpp.boundjid.bare:
+            return
+
+        if iq["type"] == "set" and iq["register"]["remove"]:
+            muc = await self.get_muc_from_stanza(iq)
+            await muc.session.on_leave_group(muc.legacy_id)
+            iq.reply().send()
+            await muc.session.bookmarks.remove(
+                muc, "You left this chat from an XMPP client."
+            )
+            return
+
+        raise XMPPError("feature-not-implemented")
+
+    @exceptions_to_xmpp_errors
+    async def on_groupchat_join(self, p: Presence):
+        if not self.xmpp.GROUPS:
+            raise XMPPError(
+                "feature-not-implemented",
+                "This gateway does not implement multi-user chats.",
+            )
+        muc = await self.get_muc_from_stanza(p)
+        await muc.join(p)
+
+    @exceptions_to_xmpp_errors
+    async def on_groupchat_direct_invite(self, msg: Message):
+        invite = msg["groupchat_invite"]
+        jid = JID(invite["jid"])
+
+        if jid.domain != self.xmpp.boundjid.bare:
+            raise XMPPError(
+                "bad-request",
+                "Legacy contacts can only be invited to legacy groups, not standard XMPP MUCs.",
+            )
+
+        if invite["password"]:
+            raise XMPPError(
+                "bad-request", "Password-protected groups are not supported"
+            )
+
+        session = await self._get_session(msg, logged=True)
+        contact = await session.contacts.by_jid(msg.get_to())
+        muc = await session.bookmarks.by_jid(jid)
+
+        await session.on_invitation(contact, muc, invite["reason"] or None)
+
+    @exceptions_to_xmpp_errors
+    async def on_groupchat_subject(self, msg: Message):
+        muc = await self.get_muc_from_stanza(msg)
+        if not muc.HAS_SUBJECT:
+            raise XMPPError(
+                "bad-request",
+                "There are no room subject in here. "
+                "Use the room configuration to update its name or description",
+            )
+        await muc.on_set_subject(msg["subject"])
+
+
+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",
+}
+
+log = logging.getLogger(__name__)

slidge/core/dispatcher/muc/owner.py

@@ -0,0 +1,96 @@
+from slixmpp import CoroutineCallback, Iq, StanzaPath
+from slixmpp.exceptions import XMPPError
+from slixmpp.plugins.xep_0004 import Form
+from slixmpp.xmlstream import StanzaBase
+
+from ..util import DispatcherMixin, exceptions_to_xmpp_errors
+
+
+class MucOwnerMixin(DispatcherMixin):
+    def __init__(self, xmpp):
+        super().__init__(xmpp)
+        xmpp.register_handler(
+            CoroutineCallback(
+                "MUCOwnerGet",
+                StanzaPath("iq@type=get/mucowner_query"),
+                self.on_muc_owner_query,
+            )
+        )
+        xmpp.register_handler(
+            CoroutineCallback(
+                "MUCOwnerSet",
+                StanzaPath("iq@type=set/mucowner_query"),
+                self.on_muc_owner_set,
+            )
+        )
+
+    @exceptions_to_xmpp_errors
+    async def on_muc_owner_query(self, iq: StanzaBase) -> None:
+        assert isinstance(iq, Iq)
+        muc = await self.get_muc_from_stanza(iq)
+
+        reply = iq.reply()
+
+        form = Form(title="Slidge room configuration")
+        form["instructions"] = (
+            "Complete this form to modify the configuration of your room."
+        )
+        form.add_field(
+            var="FORM_TYPE",
+            type="hidden",
+            value="http://jabber.org/protocol/muc#roomconfig",
+        )
+        form.add_field(
+            var="muc#roomconfig_roomname",
+            label="Natural-Language Room Name",
+            type="text-single",
+            value=muc.name,
+        )
+        if muc.HAS_DESCRIPTION:
+            form.add_field(
+                var="muc#roomconfig_roomdesc",
+                label="Short Description of Room",
+                type="text-single",
+                value=muc.description,
+            )
+
+        muc_owner = iq["mucowner_query"]
+        muc_owner.append(form)
+        reply.append(muc_owner)
+        reply.send()
+
+    @exceptions_to_xmpp_errors
+    async def on_muc_owner_set(self, iq: StanzaBase) -> None:
+        assert isinstance(iq, Iq)
+        muc = await self.get_muc_from_stanza(iq)
+        query = iq["mucowner_query"]
+
+        if form := query.get_plugin("form", check=True):
+            values = form.get_values()
+            await muc.on_set_config(
+                name=values.get("muc#roomconfig_roomname"),
+                description=(
+                    values.get("muc#roomconfig_roomdesc")
+                    if muc.HAS_DESCRIPTION
+                    else None
+                ),
+            )
+            form["type"] = "result"
+            clear = False
+        elif destroy := query.get_plugin("destroy", check=True):
+            reason = destroy["reason"] or None
+            await muc.on_destroy_request(reason)
+            user_participant = await muc.get_user_participant()
+            user_participant._affiliation = "none"
+            user_participant._role = "none"
+            presence = user_participant._make_presence(ptype="unavailable", force=True)
+            presence["muc"].enable("destroy")
+            if reason is not None:
+                presence["muc"]["destroy"]["reason"] = reason
+            user_participant._send(presence)
+            await muc.session.bookmarks.remove(muc, kick=False)
+            clear = True
+        else:
+            raise XMPPError("bad-request")
+
+        iq.reply(clear=clear).send()

slidge/core/{gateway → dispatcher/muc}/ping.py

@@ -3,39 +3,34 @@ from typing import TYPE_CHECKING
 from slixmpp import CoroutineCallback, Iq, StanzaPath
 from slixmpp.exceptions import XMPPError
 
-from ...group import LegacyMUC
+from ....group import LegacyMUC
+from ..util import DispatcherMixin, exceptions_to_xmpp_errors
 
 if TYPE_CHECKING:
-    from .base import BaseGateway
+    from slidge.core.gateway import BaseGateway
 
 
-class Ping:
+class PingMixin(DispatcherMixin):
     def __init__(self, xmpp: "BaseGateway"):
-        self.xmpp = xmpp
+        super().__init__(xmpp)
 
         xmpp.remove_handler("Ping")
         xmpp.register_handler(
             CoroutineCallback(
                 "Ping",
                 StanzaPath("iq@type=get/ping"),
-                self.__handle_ping,  # type:ignore
+                self.__handle_ping,
             )
         )
         xmpp.plugin["xep_0030"].add_feature("urn:xmpp:ping")
 
-    async def __handle_ping(self, iq: Iq):
+    @exceptions_to_xmpp_errors
+    async def __handle_ping(self, iq: Iq) -> None:
         ito = iq.get_to()
-
         if ito == self.xmpp.boundjid.bare:
             iq.reply().send()
 
-        ifrom = iq.get_from()
-        user = self.xmpp.store.users.get(ifrom)
-        if user is None:
-            raise XMPPError("registration-required")
-
-        session = self.xmpp.get_session_from_user(user)
-        session.raise_if_not_logged()
+        session = await self._get_session(iq)
 
         try:
             muc = await session.bookmarks.by_jid(ito)
@@ -58,7 +53,7 @@ class Ping:
         )
 
     @staticmethod
-    def __handle_muc_ping(muc: LegacyMUC, iq: Iq):
+    def __handle_muc_ping(muc: LegacyMUC, iq: Iq) -> None:
         if iq.get_from().resource in muc.get_user_resources():
             iq.reply().send()
         else:

slidge/core/dispatcher/presence.py

@@ -0,0 +1,177 @@
+import logging
+
+from slixmpp import JID, Presence
+from slixmpp.exceptions import XMPPError
+
+from ...util.util import merge_resources
+from ..session import BaseSession
+from .util import DispatcherMixin, exceptions_to_xmpp_errors
+
+
+class _IsDirectedAtComponent(Exception):
+    def __init__(self, session: BaseSession):
+        self.session = session
+
+
+class PresenceHandlerMixin(DispatcherMixin):
+    def __init__(self, xmpp):
+        super().__init__(xmpp)
+
+        xmpp.add_event_handler("presence_subscribe", self._handle_subscribe)
+        xmpp.add_event_handler("presence_subscribed", self._handle_subscribed)
+        xmpp.add_event_handler("presence_unsubscribe", self._handle_unsubscribe)
+        xmpp.add_event_handler("presence_unsubscribed", self._handle_unsubscribed)
+        xmpp.add_event_handler("presence_probe", self._handle_probe)
+        xmpp.add_event_handler("presence", self.on_presence)
+
+    async def __get_contact(self, pres: Presence):
+        sess = await self._get_session(pres)
+        pto = pres.get_to()
+        if pto == self.xmpp.boundjid.bare:
+            raise _IsDirectedAtComponent(sess)
+        await sess.contacts.ready
+        return await sess.contacts.by_jid(pto)
+
+    @exceptions_to_xmpp_errors
+    async def _handle_subscribe(self, pres: Presence):
+        try:
+            contact = await self.__get_contact(pres)
+        except _IsDirectedAtComponent:
+            pres.reply().send()
+            return
+
+        if contact.is_friend:
+            pres.reply().send()
+        else:
+            await contact.on_friend_request(pres["status"])
+
+    @exceptions_to_xmpp_errors
+    async def _handle_unsubscribe(self, pres: Presence):
+        pres.reply().send()
+
+        try:
+            contact = await self.__get_contact(pres)
+        except _IsDirectedAtComponent as e:
+            e.session.send_gateway_message("Bye bye!")
+            await e.session.kill_by_jid(e.session.user_jid)
+            return
+
+        contact.is_friend = False
+        await contact.on_friend_delete(pres["status"])
+
+    @exceptions_to_xmpp_errors
+    async def _handle_subscribed(self, pres: Presence):
+        try:
+            contact = await self.__get_contact(pres)
+        except _IsDirectedAtComponent:
+            return
+
+        await contact.on_friend_accept()
+
+    @exceptions_to_xmpp_errors
+    async def _handle_unsubscribed(self, pres: Presence):
+        try:
+            contact = await self.__get_contact(pres)
+        except _IsDirectedAtComponent:
+            return
+
+        if contact.is_friend:
+            contact.is_friend = False
+            await contact.on_friend_delete(pres["status"])
+
+    @exceptions_to_xmpp_errors
+    async def _handle_probe(self, pres: Presence):
+        try:
+            contact = await self.__get_contact(pres)
+        except _IsDirectedAtComponent:
+            session = await self._get_session(pres)
+            session.send_cached_presence(pres.get_from())
+            return
+        if contact.is_friend:
+            contact.send_last_presence(force=True)
+        else:
+            reply = pres.reply()
+            reply["type"] = "unsubscribed"
+            reply.send()
+
+    @exceptions_to_xmpp_errors
+    async def on_presence(self, p: Presence):
+        if p.get_plugin("muc_join", check=True):
+            # handled in on_groupchat_join
+            # without this early return, since we switch from and to in this
+            # presence stanza, on_groupchat_join ends up trying to instantiate
+            # a MUC with the user's JID, which in turn leads to slidge sending
+            # a (error) presence from=the user's JID, which terminates the
+            # XML stream.
+            return
+
+        session = await self._get_session(p)
+
+        pto = p.get_to()
+        if pto == self.xmpp.boundjid.bare:
+            session.log.debug("Received a presence from %s", p.get_from())
+            if (ptype := p.get_type()) not in _USEFUL_PRESENCES:
+                return
+            if not session.user.preferences.get("sync_presence", False):
+                session.log.debug("User does not want to sync their presence")
+                return
+            # NB: get_type() returns either a proper presence type or
+            #     a presence show if available. Weird, weird, weird slix.
+            resources = self.xmpp.roster[self.xmpp.boundjid.bare][
+                p.get_from()
+            ].resources
+            await session.on_presence(
+                p.get_from().resource,
+                ptype,  # type: ignore
+                p["status"],
+                resources,
+                merge_resources(resources),
+            )
+            if p.get_type() == "available":
+                await self.xmpp.pubsub.on_presence_available(p, None)
+            return
+
+        if p.get_type() == "available":
+            try:
+                contact = await session.contacts.by_jid(pto)
+            except XMPPError:
+                contact = None
+            if contact is not None:
+                await self.xmpp.pubsub.on_presence_available(p, contact)
+                return
+
+        muc = session.bookmarks.by_jid_only_if_exists(JID(pto.bare))
+
+        if muc is not None and p.get_type() == "unavailable":
+            return muc.on_presence_unavailable(p)
+
+        if muc is None or p.get_from().resource not in muc.get_user_resources():
+            return
+
+        if pto.resource == muc.user_nick:
+            # Ignore presence stanzas with the valid nick.
+            # even if joined to the group, we might receive those from clients,
+            # when setting a status message, or going away, etc.
+            return
+
+        # We can't use XMPPError here because from must be room@slidge/VALID-USER-NICK
+
+        error_from = JID(muc.jid)
+        error_from.resource = muc.user_nick
+        error_stanza = p.error()
+        error_stanza.set_to(p.get_from())
+        error_stanza.set_from(error_from)
+        error_stanza.enable("muc_join")
+        error_stanza.enable("error")
+        error_stanza["error"]["type"] = "cancel"
+        error_stanza["error"]["by"] = muc.jid
+        error_stanza["error"]["condition"] = "not-acceptable"
+        error_stanza["error"][
+            "text"
+        ] = "Slidge does not let you change your nickname in groups."
+        error_stanza.send()
+
+
+_USEFUL_PRESENCES = {"available", "unavailable", "away", "chat", "dnd", "xa"}
+
+log = logging.getLogger(__name__)

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

@@ -7,13 +7,16 @@ from slixmpp import JID, Iq
 from slixmpp.exceptions import XMPPError
 
 from ...db import GatewayUser
+from .. import config
+from .util import DispatcherMixin
 
 if TYPE_CHECKING:
-    from .base import BaseGateway
+    from slidge.core.gateway import BaseGateway
 
 
-class Registration:
+class RegistrationMixin(DispatcherMixin):
     def __init__(self, xmpp: "BaseGateway"):
+        super().__init__(xmpp)
         self.xmpp = xmpp
         xmpp["xep_0077"].api.register(
             self.xmpp.make_registration_form, "make_registration_form"
@@ -25,6 +28,9 @@ class Registration:
         # TODO: either fully use slixmpp internal API or rewrite registration without it at all
         xmpp["xep_0077"].api.register(lambda *a: None, "user_remove")
 
+        xmpp.add_event_handler("user_register", self._on_user_register)
+        xmpp.add_event_handler("user_unregister", self._on_user_unregister)
+
     def get_user(self, jid: JID) -> GatewayUser | None:
         return self.xmpp.store.users.get(jid)
 
@@ -60,5 +66,20 @@ class Registration:
         user.legacy_module_data.update(form_dict)
         self.xmpp.store.users.update(user)
 
+    async def _on_user_register(self, iq: Iq):
+        session = await self._get_session(iq, wait_for_ready=False)
+        for jid in config.ADMINS:
+            self.xmpp.send_message(
+                mto=jid,
+                mbody=f"{iq.get_from()} has registered",
+                mtype="chat",
+                mfrom=self.xmpp.boundjid.bare,
+            )
+        session.send_gateway_message(self.xmpp.WELCOME_MESSAGE)
+        await self.xmpp.login_wrap(session)
+
+    async def _on_user_unregister(self, iq: Iq):
+        await self.xmpp.session_cls.kill_by_jid(iq.get_from())
+
 
 log = logging.getLogger(__name__)

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__)