slidge 0.1.0rc1__py3-none-any.whl → 0.1.2__py3-none-any.whl

slidge/core/gateway/caps.py

@@ -0,0 +1,63 @@
+import logging
+from typing import TYPE_CHECKING
+
+from slixmpp import Presence
+from slixmpp.exceptions import XMPPError
+from slixmpp.xmlstream import StanzaBase
+
+from ...contact import LegacyContact
+
+if TYPE_CHECKING:
+    from .base import BaseGateway
+
+
+class Caps:
+    def __init__(self, xmpp: "BaseGateway"):
+        self.xmpp = xmpp
+        xmpp.del_filter("out", xmpp.plugin["xep_0115"]._filter_add_caps)
+        xmpp.add_filter("out", self._filter_add_caps)  # type:ignore
+
+    async def _filter_add_caps(self, stanza: StanzaBase):
+        # we rolled our own "add caps on presences" filter because
+        # there is too much magic happening in slixmpp
+        # anyway, we probably want to roll our own "dynamic disco"/caps
+        # module in the long run, so it's a step in this direction
+        if not isinstance(stanza, Presence):
+            return stanza
+
+        if stanza["type"] not in ("available", "chat", "away", "dnd", "xa"):
+            return stanza
+
+        pfrom = stanza.get_from()
+
+        caps = self.xmpp.plugin["xep_0115"]
+
+        if pfrom != self.xmpp.boundjid.bare:
+            try:
+                session = self.xmpp.get_session_from_jid(stanza.get_to())
+            except XMPPError:
+                log.debug("not adding caps 1")
+                return stanza
+
+            if session is None:
+                return stanza
+
+            await session.ready
+
+            entity = await session.get_contact_or_group_or_participant(pfrom)
+            if not isinstance(entity, LegacyContact):
+                return stanza
+            ver = await entity.get_caps_ver(pfrom)
+        else:
+            ver = await caps.get_verstring(pfrom)
+
+        log.debug("Ver: %s", ver)
+
+        if ver:
+            stanza["caps"]["node"] = caps.caps_node
+            stanza["caps"]["hash"] = caps.hash
+            stanza["caps"]["ver"] = ver
+        return stanza
+
+
+log = logging.getLogger(__name__)

slidge/core/gateway/delivery_receipt.py

@@ -0,0 +1,52 @@
+"""
+XEP-0184 Delivery Receipts
+
+The corresponding slixmpp module is a bit too rigid, this is our implementation
+to selectively choose when we send delivery receipts
+"""
+
+from typing import TYPE_CHECKING
+
+from slixmpp import JID, Message
+from slixmpp.types import MessageTypes
+
+if TYPE_CHECKING:
+    from .base import BaseGateway
+
+
+class DeliveryReceipt:
+    def __init__(self, xmpp: "BaseGateway"):
+        self.xmpp = xmpp
+
+    def ack(self, msg: Message):
+        """
+        Send a XEP-0184 (delivery receipt) in response to a message,
+        if appropriate.
+
+        :param msg:
+        """
+        if not self.requires_receipt(msg):
+            return
+        ack = self.make_ack(msg["id"], msg["to"], msg["from"].bare, msg["type"])
+        ack.send()
+
+    def make_ack(self, msg_id: str, mfrom: JID, mto: JID, mtype: MessageTypes = "chat"):
+        ack = self.xmpp.Message()
+        ack["type"] = mtype
+        ack["to"] = mto
+        ack["from"] = mfrom
+        ack["receipt"] = msg_id
+        return ack
+
+    def requires_receipt(self, msg: Message):
+        """
+        Check if a message is eligible for a delivery receipt.
+
+        :param msg:
+        :return:
+        """
+        return (
+            msg["request_receipt"]
+            and msg["type"] in self.xmpp.plugin["xep_0184"].ack_types
+            and not msg["receipt"]
+        )

slidge/core/gateway/disco.py

@@ -0,0 +1,80 @@
+import logging
+from typing import TYPE_CHECKING, Any, Optional
+
+from slixmpp.exceptions import XMPPError
+from slixmpp.plugins.xep_0030.stanza.items import DiscoItems
+from slixmpp.types import OptJid
+
+from ...util.db import user_store
+
+if TYPE_CHECKING:
+    from .base import BaseGateway
+
+
+class Disco:
+    def __init__(self, xmpp: "BaseGateway"):
+        self.xmpp = xmpp
+
+        xmpp.plugin["xep_0030"].set_node_handler(
+            "get_info",
+            jid=None,
+            node=None,
+            handler=self.get_info,
+        )
+
+        xmpp.plugin["xep_0030"].set_node_handler(
+            "get_items",
+            jid=None,
+            node=None,
+            handler=self.get_items,
+        )
+
+    async def get_info(
+        self, jid: OptJid, node: Optional[str], ifrom: OptJid, data: Any
+    ):
+        if ifrom == self.xmpp.boundjid.bare or jid in (self.xmpp.boundjid.bare, None):
+            return self.xmpp.plugin["xep_0030"].static.get_info(jid, node, ifrom, data)
+
+        if ifrom is None:
+            raise XMPPError("subscription-required")
+
+        user = user_store.get_by_jid(ifrom)
+        if user is None:
+            raise XMPPError("registration-required")
+        session = self.xmpp.get_session_from_user(user)
+        await session.wait_for_ready()
+
+        log.debug("Looking for entity: %s", jid)
+
+        assert jid is not None
+        entity = await session.get_contact_or_group_or_participant(jid)
+
+        if entity is None:
+            raise XMPPError("item-not-found")
+
+        return await entity.get_disco_info(jid, node)
+
+    async def get_items(
+        self, jid: OptJid, node: Optional[str], ifrom: OptJid, data: Any
+    ):
+        if ifrom is None:
+            raise XMPPError("bad-request")
+
+        if jid != self.xmpp.boundjid.bare:
+            return DiscoItems()
+
+        user = user_store.get_by_jid(ifrom)
+        if user is None:
+            raise XMPPError("registration-required")
+
+        session = self.xmpp.get_session_from_user(user)
+        await session.wait_for_ready()
+
+        d = DiscoItems()
+        for muc in sorted(session.bookmarks, key=lambda m: m.name):
+            d.add_item(muc.jid, name=muc.name)
+
+        return d
+
+
+log = logging.getLogger(__name__)

slidge/core/gateway/mam.py

@@ -0,0 +1,75 @@
+from typing import TYPE_CHECKING
+
+from slixmpp import CoroutineCallback, Iq, StanzaPath
+from slixmpp.exceptions import XMPPError
+
+from ...util.db import user_store
+
+if TYPE_CHECKING:
+    from .base import BaseGateway
+
+
+class Mam:
+    def __init__(self, xmpp: "BaseGateway"):
+        self.xmpp = xmpp
+        xmpp.register_handler(
+            CoroutineCallback(
+                "MAM_query",
+                StanzaPath("iq@type=set/mam"),
+                self.__handle_mam,  # type:ignore
+            )
+        )
+        xmpp.register_handler(
+            CoroutineCallback(
+                "MAM_get_from",
+                StanzaPath("iq@type=get/mam"),
+                self.__handle_mam_get_form,  # type:ignore
+            )
+        )
+        xmpp.register_handler(
+            CoroutineCallback(
+                "MAM_get_meta",
+                StanzaPath("iq@type=get/mam_metadata"),
+                self.__handle_mam_metadata,  # type:ignore
+            )
+        )
+
+    async def __handle_mam(self, iq: Iq):
+        muc = await self.xmpp.get_muc_from_stanza(iq)
+        await muc.send_mam(iq)
+
+    async def __handle_mam_get_form(self, iq: Iq):
+        ito = iq.get_to()
+
+        if ito == self.xmpp.boundjid.bare:
+            raise XMPPError(
+                text="No MAM on the component itself, use a JID with a resource"
+            )
+
+        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)
+
+        await session.bookmarks.by_jid(ito)
+
+        reply = iq.reply()
+        form = self.xmpp.plugin["xep_0004"].make_form()
+        form.add_field(ftype="hidden", var="FORM_TYPE", value="urn:xmpp:mam:2")
+        form.add_field(ftype="jid-single", var="with")
+        form.add_field(ftype="text-single", var="start")
+        form.add_field(ftype="text-single", var="end")
+        form.add_field(ftype="text-single", var="before-id")
+        form.add_field(ftype="text-single", var="after-id")
+        form.add_field(ftype="boolean", var="include-groupchat")
+        field = form.add_field(ftype="list-multi", var="ids")
+        field["validate"]["datatype"] = "xs:string"
+        field["validate"]["open"] = True
+        reply["mam"].append(form)
+        reply.send()
+
+    async def __handle_mam_metadata(self, iq: Iq):
+        muc = await self.xmpp.get_muc_from_stanza(iq)
+        await muc.send_mam_metadata(iq)

slidge/core/gateway/muc_admin.py

@@ -0,0 +1,35 @@
+from typing import TYPE_CHECKING
+
+from slixmpp import CoroutineCallback, Iq, StanzaPath
+from slixmpp.exceptions import XMPPError
+
+if TYPE_CHECKING:
+    from .base import BaseGateway
+
+
+class MucAdmin:
+    def __init__(self, xmpp: "BaseGateway"):
+        self.xmpp = xmpp
+        xmpp.register_handler(
+            CoroutineCallback(
+                "muc#admin",
+                StanzaPath("iq@type=get/mucadmin_query"),
+                self._handle_admin,  # type: ignore
+            )
+        )
+
+    async def _handle_admin(self, iq: Iq):
+        muc = await self.xmpp.get_muc_from_stanza(iq)
+
+        affiliation = iq["mucadmin_query"]["item"]["affiliation"]
+
+        if not affiliation:
+            raise XMPPError("bad-request")
+
+        reply = iq.reply()
+        reply.enable("mucadmin_query")
+        for participant in await muc.get_participants():
+            if not participant.affiliation == affiliation:
+                continue
+            reply["mucadmin_query"].append(participant.mucadmin_item())
+        reply.send()

slidge/core/gateway/ping.py

@@ -0,0 +1,66 @@
+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
+
+if TYPE_CHECKING:
+    from .base import BaseGateway
+
+
+class Ping:
+    def __init__(self, xmpp: "BaseGateway"):
+        self.xmpp = xmpp
+
+        xmpp.remove_handler("Ping")
+        xmpp.register_handler(
+            CoroutineCallback(
+                "Ping",
+                StanzaPath("iq@type=get/ping"),
+                self.__handle_ping,  # type:ignore
+            )
+        )
+        xmpp.plugin["xep_0030"].add_feature("urn:xmpp:ping")
+
+    async def __handle_ping(self, iq: Iq):
+        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()
+
+        try:
+            muc = await session.bookmarks.by_jid(ito)
+        except XMPPError:
+            pass
+        else:
+            self.__handle_muc_ping(muc, iq)
+            return
+
+        try:
+            await session.contacts.by_jid(ito)
+        except XMPPError:
+            pass
+        else:
+            iq.reply().send()
+            return
+
+        raise XMPPError(
+            "item-not-found", f"This JID does not match anything slidge knows: {ito}"
+        )
+
+    @staticmethod
+    def __handle_muc_ping(muc: LegacyMUC, iq: Iq):
+        if iq.get_from().resource in muc.user_resources:
+            iq.reply().send()
+        else:
+            raise XMPPError("not-acceptable", etype="cancel", by=muc.jid)

slidge/core/gateway/presence.py

@@ -0,0 +1,95 @@
+import logging
+
+from slixmpp import JID, Presence
+
+from ..session import BaseSession
+
+
+class _IsDirectedAtComponent(Exception):
+    def __init__(self, session: BaseSession):
+        self.session = session
+
+
+class PresenceHandlerMixin:
+    boundjid: JID
+
+    def get_session_from_stanza(self, s) -> BaseSession:
+        raise NotImplementedError
+
+    async def __get_contact(self, pres: Presence):
+        sess = await self.__get_session(pres)
+        pto = pres.get_to()
+        if pto == self.boundjid.bare:
+            raise _IsDirectedAtComponent(sess)
+        await sess.contacts.ready
+        return await sess.contacts.by_jid(pto)
+
+    async def __get_session(self, p: Presence):
+        sess = self.get_session_from_stanza(p)
+        return sess
+
+    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"])
+
+    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"])
+
+    async def _handle_subscribed(self, pres: Presence):
+        try:
+            contact = await self.__get_contact(pres)
+        except _IsDirectedAtComponent:
+            return
+
+        await contact.on_friend_accept()
+
+    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"])
+
+    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()
+
+    async def _handle_new_subscription(self, pres: Presence):
+        pass
+
+    async def _handle_removed_subscription(self, pres: Presence):
+        pass
+
+
+log = logging.getLogger(__name__)

slidge/core/gateway/registration.py

@@ -0,0 +1,53 @@
+import logging
+from typing import TYPE_CHECKING, Optional
+
+from slixmpp import JID, Iq
+
+from ...util.db import user_store
+
+if TYPE_CHECKING:
+    from .base import BaseGateway
+
+
+class Registration:
+    def __init__(self, xmpp: "BaseGateway"):
+        self.xmpp = xmpp
+        xmpp["xep_0077"].api.register(
+            user_store.get,
+            "user_get",
+        )
+        xmpp["xep_0077"].api.register(
+            user_store.remove,
+            "user_remove",
+        )
+        xmpp["xep_0077"].api.register(
+            self.xmpp.make_registration_form, "make_registration_form"
+        )
+        xmpp["xep_0077"].api.register(self._user_validate, "user_validate")
+        xmpp["xep_0077"].api.register(self._user_modify, "user_modify")
+
+    async def _user_validate(self, _gateway_jid, _node, ifrom: JID, iq: Iq):
+        """
+        SliXMPP internal API stuff
+        """
+        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)
+        await xmpp.user_prevalidate(ifrom, form_dict)
+        log.info("New user: %s", ifrom.bare)
+        user_store.add(ifrom, form_dict)
+
+    async def _user_modify(
+        self, _gateway_jid, _node, ifrom: JID, form_dict: dict[str, Optional[str]]
+    ):
+        """
+        SliXMPP internal API stuff
+        """
+        user = user_store.get_by_jid(ifrom)
+        log.debug("Modify user: %s", user)
+        await self.xmpp.user_prevalidate(ifrom, form_dict)
+        user_store.add(ifrom, form_dict)
+
+
+log = logging.getLogger(__name__)

slidge/core/gateway/search.py

@@ -0,0 +1,102 @@
+from typing import TYPE_CHECKING
+
+from slixmpp import JID, CoroutineCallback, Iq, StanzaPath
+from slixmpp.exceptions import XMPPError
+
+from ...util.db import user_store
+
+if TYPE_CHECKING:
+    from .base import BaseGateway
+
+
+class Search:
+    def __init__(self, xmpp: "BaseGateway"):
+        self.xmpp = xmpp
+
+        xmpp["xep_0055"].api.register(self.search_get_form, "search_get_form")
+        xmpp["xep_0055"].api.register(self._search_query, "search_query")
+
+        xmpp.plugin["xep_0030"].add_feature("jabber:iq:gateway")
+        xmpp.register_handler(
+            CoroutineCallback(
+                "iq:gateway",
+                StanzaPath("iq/gateway"),
+                self._handle_gateway_iq,  # type: ignore
+            )
+        )
+
+    async def search_get_form(self, _gateway_jid, _node, ifrom: JID, iq: Iq):
+        """
+        Prepare the search form using :attr:`.BaseSession.SEARCH_FIELDS`
+        """
+        user = user_store.get_by_jid(ifrom)
+        if user is None:
+            raise XMPPError(text="Search is only allowed for registered users")
+
+        xmpp = self.xmpp
+
+        reply = iq.reply()
+        form = reply["search"]["form"]
+        form["title"] = xmpp.SEARCH_TITLE
+        form["instructions"] = xmpp.SEARCH_INSTRUCTIONS
+        for field in xmpp.SEARCH_FIELDS:
+            form.append(field.get_xml())
+        return reply
+
+    async def _search_query(self, _gateway_jid, _node, ifrom: JID, iq: Iq):
+        """
+        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")
+
+        result = await self.xmpp.get_session_from_stanza(iq).on_search(
+            iq["search"]["form"].get_values()
+        )
+
+        if not result:
+            raise XMPPError("item-not-found", text="Nothing was found")
+
+        reply = iq.reply()
+        form = reply["search"]["form"]
+        for field in result.fields:
+            form.add_reported(field.var, label=field.label, type=field.type)
+        for item in result.items:
+            form.add_item(item)
+        return reply
+
+    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"
+            )
+
+        field = self.xmpp.SEARCH_FIELDS[0]
+
+        reply = iq.reply()
+        if iq["type"] == "get":
+            reply["gateway"]["desc"] = self.xmpp.SEARCH_TITLE
+            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(
+                    "item-not-found", "No contact was found with the info you provided."
+                )
+            if len(result.items) > 1:
+                raise XMPPError(
+                    "bad-request", "Your search yielded more than one result."
+                )
+            reply["gateway"]["jid"] = result.items[0]["jid"]
+
+        reply.send()