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

slidge/core/dispatcher/muc/__init__.py

@@ -0,0 +1,12 @@
+from .admin import MucAdminMixin
+from .mam import MamMixin
+from .misc import MucMiscMixin
+from .owner import MucOwnerMixin
+from .ping import PingMixin
+
+
+class MucMixin(PingMixin, MamMixin, MucAdminMixin, MucOwnerMixin, MucMiscMixin):
+    pass
+
+
+__all__ = ("MucMixin",)

slidge/core/dispatcher/muc/admin.py

@@ -0,0 +1,98 @@
+from slixmpp import JID, CoroutineCallback, Iq, StanzaPath
+from slixmpp.exceptions import XMPPError
+from slixmpp.xmlstream import StanzaBase
+
+from ..util import DispatcherMixin, exceptions_to_xmpp_errors
+
+
+class MucAdminMixin(DispatcherMixin):
+    def __init__(self, xmpp) -> None:
+        super().__init__(xmpp)
+        self.xmpp.register_handler(
+            CoroutineCallback(
+                "MUCModerate",
+                StanzaPath("iq/apply_to/moderate"),
+                self.on_user_moderation,
+            )
+        )
+        self.xmpp.register_handler(
+            CoroutineCallback(
+                "MUCSetAffiliation",
+                StanzaPath("iq@type=set/mucadmin_query"),
+                self.on_user_set_affiliation,
+            )
+        )
+        self.xmpp.register_handler(
+            CoroutineCallback(
+                "MUCGetAffiliation",
+                StanzaPath("iq@type=get/mucadmin_query"),
+                self.on_muc_admin_query_get,
+            )
+        )
+
+    @exceptions_to_xmpp_errors
+    async def on_user_moderation(self, iq: StanzaBase) -> None:
+        assert isinstance(iq, Iq)
+        muc = await self.get_muc_from_stanza(iq)
+
+        apply_to = iq["apply_to"]
+        xmpp_id = apply_to["id"]
+        if not xmpp_id:
+            raise XMPPError("bad-request", "Missing moderated message ID")
+
+        moderate = apply_to["moderate"]
+        if not moderate["retract"]:
+            raise XMPPError(
+                "feature-not-implemented",
+                "Slidge only implements moderation/retraction",
+            )
+
+        legacy_id = self._xmpp_msg_id_to_legacy(muc.session, xmpp_id)
+        await muc.session.on_moderate(muc, legacy_id, moderate["reason"] or None)
+        iq.reply(clear=True).send()
+
+    @exceptions_to_xmpp_errors
+    async def on_user_set_affiliation(self, iq: StanzaBase) -> None:
+        assert isinstance(iq, Iq)
+        muc = await self.get_muc_from_stanza(iq)
+
+        item = iq["mucadmin_query"]["item"]
+        if item["jid"]:
+            contact = await muc.session.contacts.by_jid(JID(item["jid"]))
+        else:
+            part = await muc.get_participant(
+                item["nick"], fill_first=True, raise_if_not_found=True
+            )
+            assert part.contact is not None
+            contact = part.contact
+
+        if item["affiliation"]:
+            await muc.on_set_affiliation(
+                contact,
+                item["affiliation"],
+                item["reason"] or None,
+                item["nick"] or None,
+            )
+        elif item["role"] == "none":
+            await muc.on_kick(contact, item["reason"] or None)
+
+        iq.reply(clear=True).send()
+
+    @exceptions_to_xmpp_errors
+    async def on_muc_admin_query_get(self, iq: StanzaBase) -> None:
+        assert isinstance(iq, Iq)
+        affiliation = iq["mucadmin_query"]["item"]["affiliation"]
+
+        if not affiliation:
+            raise XMPPError("bad-request")
+
+        session = await self._get_session(iq, 1, logged=True)
+        muc = await session.bookmarks.by_jid(iq.get_to())
+
+        reply = iq.reply()
+        reply.enable("mucadmin_query")
+        async for participant in muc.get_participants():
+            if not participant.affiliation == affiliation:
+                continue
+            reply["mucadmin_query"].append(participant.mucadmin_item())
+        reply.send()

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

@@ -1,42 +1,57 @@
+import asyncio
 from typing import TYPE_CHECKING
 
 from slixmpp import CoroutineCallback, Iq, StanzaPath
 from slixmpp.exceptions import XMPPError
+from slixmpp.xmlstream import StanzaBase
+
+from ... import config
+from ..util import DispatcherMixin, exceptions_to_xmpp_errors
 
 if TYPE_CHECKING:
-    from .base import BaseGateway
+    from slidge.core.gateway import BaseGateway
 
 
-class Mam:
+class MamMixin(DispatcherMixin):
     def __init__(self, xmpp: "BaseGateway"):
-        self.xmpp = xmpp
+        super().__init__(xmpp)
+        self.__mam_cleanup_task = xmpp.loop.create_task(self.__mam_cleanup())
         xmpp.register_handler(
             CoroutineCallback(
                 "MAM_query",
                 StanzaPath("iq@type=set/mam"),
-                self.__handle_mam,  # type:ignore
+                self.__handle_mam,
             )
         )
         xmpp.register_handler(
             CoroutineCallback(
                 "MAM_get_from",
                 StanzaPath("iq@type=get/mam"),
-                self.__handle_mam_get_form,  # type:ignore
+                self.__handle_mam_get_form,
             )
         )
         xmpp.register_handler(
             CoroutineCallback(
                 "MAM_get_meta",
                 StanzaPath("iq@type=get/mam_metadata"),
-                self.__handle_mam_metadata,  # type:ignore
+                self.__handle_mam_metadata,
             )
         )
 
+    async def __mam_cleanup(self):
+        if not config.MAM_MAX_DAYS:
+            return
+        while True:
+            await asyncio.sleep(3600 * 6)
+            self.xmpp.store.mam.nuke_older_than(config.MAM_MAX_DAYS)
+
+    @exceptions_to_xmpp_errors
     async def __handle_mam(self, iq: Iq):
-        muc = await self.xmpp.get_muc_from_stanza(iq)
+        muc = await self.get_muc_from_stanza(iq)
         await muc.send_mam(iq)
 
-    async def __handle_mam_get_form(self, iq: Iq):
+    async def __handle_mam_get_form(self, iq: StanzaBase):
+        assert isinstance(iq, Iq)
         ito = iq.get_to()
 
         if ito == self.xmpp.boundjid.bare:
@@ -44,12 +59,7 @@ class Mam:
                 text="No MAM on the component itself, use a JID with a resource"
             )
 
-        user = self.xmpp.store.users.get(iq.get_from())
-        if user is None:
-            raise XMPPError("registration-required")
-
-        session = self.xmpp.get_session_from_user(user)
-
+        session = await self._get_session(iq, 0, logged=True)
         await session.bookmarks.by_jid(ito)
 
         reply = iq.reply()
@@ -67,6 +77,7 @@ class Mam:
         reply["mam"].append(form)
         reply.send()
 
+    @exceptions_to_xmpp_errors
     async def __handle_mam_metadata(self, iq: Iq):
-        muc = await self.xmpp.get_muc_from_stanza(iq)
+        muc = await self.get_muc_from_stanza(iq)
         await muc.send_mam_metadata(iq)

slidge/core/dispatcher/muc/misc.py

@@ -0,0 +1,118 @@
+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()
+            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)
+            muc.session.bookmarks.remove(muc)
+            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__)