slidge 0.1.3__py3-none-any.whl → 0.2.0__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,40 +3,34 @@ from typing import TYPE_CHECKING
 from slixmpp import CoroutineCallback, Iq, StanzaPath
 from slixmpp.exceptions import XMPPError
 
-from ...group import LegacyMUC
-from ...util.db import user_store
+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 = user_store.get_by_jid(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)
@@ -59,8 +53,8 @@ class Ping:
         )
 
     @staticmethod
-    def __handle_muc_ping(muc: LegacyMUC, iq: Iq):
-        if iq.get_from().resource in muc.user_resources:
+    def __handle_muc_ping(muc: LegacyMUC, iq: Iq) -> None:
+        if iq.get_from().resource in muc.get_user_resources():
             iq.reply().send()
         else:
             raise XMPPError("not-acceptable", etype="cancel", by=muc.jid)

slidge/core/dispatcher/presence.py

@@ -0,0 +1,176 @@
+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 XMPPError does not have a way to
+        # add the <x xmlns="http://jabber.org/protocol/muc" /> element
+
+        error_stanza = p.error()
+        error_stanza.set_to(p.get_from())
+        error_stanza.set_from(pto)
+        error_stanza.enable("muc_join")  # <x xmlns="http://jabber.org/protocol/muc" />
+        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/dispatcher/registration.py

@@ -0,0 +1,85 @@
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING, Optional
+
+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 slidge.core.gateway import BaseGateway
+
+
+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"
+        )
+        xmpp["xep_0077"].api.register(self._user_get, "user_get")
+        xmpp["xep_0077"].api.register(self._user_validate, "user_validate")
+        xmpp["xep_0077"].api.register(self._user_modify, "user_modify")
+        # kept for slixmpp internal API compat
+        # 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)
+
+    async def _user_get(
+        self, _gateway_jid, _node, ifrom: JID, iq: Iq
+    ) -> GatewayUser | None:
+        if ifrom is None:
+            ifrom = iq.get_from()
+        return self.get_user(ifrom)
+
+    async def _user_validate(self, _gateway_jid, _node, ifrom: JID, iq: Iq):
+        xmpp = self.xmpp
+        log.debug("User validate: %s", ifrom.bare)
+        form_dict = {f.var: iq.get(f.var) for f in xmpp.REGISTRATION_FIELDS}
+        xmpp.raise_if_not_allowed_jid(ifrom)
+        legacy_module_data = await xmpp.user_prevalidate(ifrom, form_dict)
+        if legacy_module_data is None:
+            legacy_module_data = form_dict
+        user = self.xmpp.store.users.new(
+            jid=ifrom,
+            legacy_module_data=legacy_module_data,  # type:ignore
+        )
+        log.info("New user: %s", user)
+
+    async def _user_modify(
+        self, _gateway_jid, _node, ifrom: JID, form_dict: dict[str, Optional[str]]
+    ):
+        await self.xmpp.user_prevalidate(ifrom, form_dict)
+        log.debug("Modify user: %s", ifrom)
+        user = self.xmpp.store.users.get(ifrom)
+        if user is None:
+            raise XMPPError("internal-server-error", "User not found")
+        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,15 +3,15 @@ from typing import TYPE_CHECKING
 from slixmpp import JID, CoroutineCallback, Iq, StanzaPath
 from slixmpp.exceptions import XMPPError
 
-from ...util.db import user_store
+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")
@@ -29,7 +29,7 @@ class Search:
         """
         Prepare the search form using :attr:`.BaseSession.SEARCH_FIELDS`
         """
-        user = user_store.get_by_jid(ifrom)
+        user = self.xmpp.store.users.get(ifrom)
         if user is None:
             raise XMPPError(text="Search is only allowed for registered users")
 
@@ -47,13 +47,9 @@ class Search:
         """
         Handles a search request
         """
-        user = user_store.get_by_jid(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")
@@ -66,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 = user_store.get_by_jid(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()
@@ -87,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(