v1.3.5

2026-08-02 18:57:40 +02:00
parent 5e5ab8681a
commit 6fa59321c0
5759 changed files with 712133 additions and 66 deletions
@@ -0,0 +1,38 @@
+########################################################################
+# File name: __init__.py
+# This file is part of: aioxmpp
+#
+# LICENSE
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as
+# published by the Free Software Foundation, either version 3 of the
+# License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this program.  If not, see
+# <http://www.gnu.org/licenses/>.
+#
+########################################################################
+"""
+:mod:`~aioxmpp.blocking` --- Blocking Command support (:xep:`0191`)
+###################################################################
+
+This subpackage provides client side support for :xep:`0191`.
+
+The public interface of this package consists of a single
+:class:`~aioxmpp.Service`:
+
+.. currentmodule:: aioxmpp
+
+.. autoclass:: BlockingClient
+
+.. currentmodule:: aioxmpp.blocking
+
+"""
+from .service import BlockingClient  # NOQA: F401
@@ -0,0 +1,236 @@
+########################################################################
+# File name: service.py
+# This file is part of: aioxmpp
+#
+# LICENSE
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as
+# published by the Free Software Foundation, either version 3 of the
+# License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this program.  If not, see
+# <http://www.gnu.org/licenses/>.
+#
+########################################################################
+import asyncio
+
+import aioxmpp
+import aioxmpp.callbacks as callbacks
+import aioxmpp.service as service
+
+from aioxmpp.utils import namespaces
+
+from . import xso as blocking_xso
+
+
+class BlockingClient(service.Service):
+    """
+    A :class:`~aioxmpp.service.Service` implementing :xep:`Blocking
+    Command <191>`.
+
+    This service maintains the list of blocked JIDs and allows
+    manipulating the blocklist.
+
+    Attribute:
+
+    .. autoattribute:: blocklist
+
+    Signals:
+
+    .. signal:: on_initial_blocklist_received(blocklist)
+
+       Fires when the initial blocklist was received from the server.
+
+       :param blocklist: the initial blocklist
+       :type blocklist: :class:`~collections.abc.Set` of :class:`~aioxmpp.JID`
+
+    .. signal:: on_jids_blocked(blocked_jids)
+
+       Fires when additional JIDs are blocked.
+
+       :param blocked_jids: the newly blocked JIDs
+       :type blocked_jids: :class:`~collections.abc.Set`
+           of :class:`~aioxmpp.JID`
+
+    .. signal:: on_jids_blocked(blocked_jids)
+
+       Fires when JIDs are unblocked.
+
+       :param unblocked_jids: the now unblocked JIDs
+       :type unblocked_jids: :class:`~collections.abc.Set`
+           of :class:`~aioxmpp.JID`
+
+    Coroutine methods:
+
+    .. automethod:: block_jids
+
+    .. automethod:: unblock_jids
+
+    .. automethod:: unblock_all
+    """
+    ORDER_AFTER = [aioxmpp.DiscoClient]
+
+    def __init__(self, client, **kwargs):
+        super().__init__(client, **kwargs)
+        self._blocklist = None
+        self._lock = asyncio.Lock()
+        self._disco = self.dependencies[aioxmpp.DiscoClient]
+
+    on_jids_blocked = callbacks.Signal()
+    on_jids_unblocked = callbacks.Signal()
+    on_initial_blocklist_received = callbacks.Signal()
+
+    async def _check_for_blocking(self):
+        server_info = await self._disco.query_info(
+            self.client.local_jid.replace(
+                resource=None,
+                localpart=None,
+            )
+        )
+
+        if namespaces.xep0191 not in server_info.features:
+            self._blocklist = None
+            raise RuntimeError("server does not support blocklists!")
+
+    @service.depsignal(aioxmpp.Client, "before_stream_established")
+    async def _get_initial_blocklist(self):
+        try:
+            await self._check_for_blocking()
+        except RuntimeError:
+            self.logger.info(
+                "server does not support block lists, skipping initial fetch"
+            )
+            return True
+
+        if self._blocklist is None:
+            async with self._lock:
+                iq = aioxmpp.IQ(
+                    type_=aioxmpp.IQType.GET,
+                    payload=blocking_xso.BlockList(),
+                )
+                result = await self.client.send(iq)
+                self._blocklist = frozenset(result.items)
+            self.on_initial_blocklist_received(self._blocklist)
+
+        return True
+
+    @property
+    def blocklist(self):
+        """
+        :class:`~collections.abc.Set` of JIDs blocked by the account.
+        """
+        return self._blocklist
+
+    async def block_jids(self, jids_to_block):
+        """
+        Add the JIDs in the sequence `jids_to_block` to the client's
+        blocklist.
+        """
+        await self._check_for_blocking()
+
+        if not jids_to_block:
+            return
+
+        cmd = blocking_xso.BlockCommand(jids_to_block)
+        iq = aioxmpp.IQ(
+            type_=aioxmpp.IQType.SET,
+            payload=cmd,
+        )
+        await self.client.send(iq)
+
+    async def unblock_jids(self, jids_to_unblock):
+        """
+        Remove the JIDs in the sequence `jids_to_block` from the
+        client's blocklist.
+        """
+        await self._check_for_blocking()
+
+        if not jids_to_unblock:
+            return
+
+        cmd = blocking_xso.UnblockCommand(jids_to_unblock)
+        iq = aioxmpp.IQ(
+            type_=aioxmpp.IQType.SET,
+            payload=cmd,
+        )
+        await self.client.send(iq)
+
+    async def unblock_all(self):
+        """
+        Unblock all JIDs currently blocked.
+        """
+        await self._check_for_blocking()
+
+        cmd = blocking_xso.UnblockCommand()
+        iq = aioxmpp.IQ(
+            type_=aioxmpp.IQType.SET,
+            payload=cmd,
+        )
+        await self.client.send(iq)
+
+    @service.iq_handler(aioxmpp.IQType.SET, blocking_xso.BlockCommand)
+    async def handle_block_push(self, block_command):
+        diff = ()
+        async with self._lock:
+            if self._blocklist is None:
+                # this means the stream was destroyed while we were waiting for
+                # the lock/while the handler was enqueued for scheduling, or
+                # the server is buggy and sends pushes before we fetched the
+                # blocklist
+                return
+
+            if (block_command.from_ is None or
+                    block_command.from_ == self.client.local_jid.bare() or
+                    # WORKAROUND: ejabberd#2287
+                    block_command.from_ == self.client.local_jid):
+                diff = frozenset(block_command.payload.items)
+                self._blocklist |= diff
+            else:
+                self.logger.debug(
+                    "received block push from unauthorized JID: %s",
+                    block_command.from_,
+                )
+
+        if diff:
+            self.on_jids_blocked(diff)
+
+    @service.iq_handler(aioxmpp.IQType.SET, blocking_xso.UnblockCommand)
+    async def handle_unblock_push(self, unblock_command):
+        diff = ()
+        async with self._lock:
+            if self._blocklist is None:
+                # this means the stream was destroyed while we were waiting for
+                # the lock/while the handler was enqueued for scheduling, or
+                # the server is buggy and sends pushes before we fetched the
+                # blocklist
+                return
+
+            if (unblock_command.from_ is None or
+                    unblock_command.from_ == self.client.local_jid.bare() or
+                    # WORKAROUND: ejabberd#2287
+                    unblock_command.from_ == self.client.local_jid):
+                if not unblock_command.payload.items:
+                    diff = frozenset(self._blocklist)
+                    self._blocklist = frozenset()
+                else:
+                    diff = frozenset(unblock_command.payload.items)
+                    self._blocklist -= diff
+            else:
+                self.logger.debug(
+                    "received unblock push from unauthorized JID: %s",
+                    unblock_command.from_,
+                )
+        if diff:
+            self.on_jids_unblocked(diff)
+
+    @service.depsignal(aioxmpp.stream.StanzaStream,
+                       "on_stream_destroyed")
+    def handle_stream_destroyed(self, reason):
+        self._blocklist = None
@@ -0,0 +1,113 @@
+########################################################################
+# File name: xso.py
+# This file is part of: aioxmpp
+#
+# LICENSE
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as
+# published by the Free Software Foundation, either version 3 of the
+# License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this program.  If not, see
+# <http://www.gnu.org/licenses/>.
+#
+########################################################################
+import aioxmpp
+import aioxmpp.xso
+
+from aioxmpp.utils import namespaces
+
+namespaces.xep0191 = "urn:xmpp:blocking"
+
+
+# this XSO represents a single block list item.
+class BlockItem(aioxmpp.xso.XSO):
+    # define the tag we are matching for
+    # tags consist of an XML namespace URI and an XML element
+    TAG = (namespaces.xep0191, "item")
+
+    # bind the ``jid`` python attribute to refer to the ``jid`` XML attribute.
+    # in addition, automatic conversion between actual JID objects and XML
+    # character data is requested by specifying the `type_` argument as
+    # xso.JID() object.
+    jid = aioxmpp.xso.Attr(
+        "jid",
+        type_=aioxmpp.xso.JID()
+    )
+
+
+# we now declare a custom type to convert between JID objects and BlockItem
+# instances.
+# we can use this custom type together with xso.ChildValueList to access the
+# list of <item xmlns="urn:xmpp:blocking" /> elements like a normal python list
+# of JIDs.
+class BlockItemType(aioxmpp.xso.AbstractElementType):
+    # unpack converts from the "raw" XSO to the
+    # "rich" python representation, in this case a JID object
+    # think of unpack like of a high-level struct.unpack: we convert
+    # wire-format (XML trees) to python values
+    def unpack(self, item):
+        return item.jid
+
+    # pack is the reverse operation of unpack
+    def pack(self, jid):
+        item = BlockItem()
+        item.jid = jid
+        return item
+
+    # we have to tell the XSO framework what XSO types are supported by this
+    # element type
+    def get_xso_types(self):
+        return [BlockItem]
+
+
+# the decorator tells the IQ stanza class that this is a valid payload; that is
+# required to be able to *receive* payloads of this type (sending works without
+# that decorator, but is not recommended)
+@aioxmpp.stanza.IQ.as_payload_class
+class BlockList(aioxmpp.xso.XSO):
+    TAG = (namespaces.xep0191, "blocklist")
+
+    # this does not get an __init__ method, since the client never
+    # creates a BlockList with entries.
+
+    # xso.ChildValueList uses an AbstractElementType (like the one we defined
+    # above) to convert between child XSO instances and other python objects.
+    # it is accessed like a normal list, but when parsing/serialising, the
+    # elements are converted to XML structures using the given type.
+    items = aioxmpp.xso.ChildValueList(
+        BlockItemType()
+    )
+
+
+@aioxmpp.stanza.IQ.as_payload_class
+class BlockCommand(aioxmpp.xso.XSO):
+    TAG = (namespaces.xep0191, "block")
+
+    def __init__(self, jids_to_block=None):
+        if jids_to_block is not None:
+            self.items[:] = jids_to_block
+
+    items = aioxmpp.xso.ChildValueList(
+        BlockItemType()
+    )
+
+
+@aioxmpp.stanza.IQ.as_payload_class
+class UnblockCommand(aioxmpp.xso.XSO):
+    TAG = (namespaces.xep0191, "unblock")
+
+    def __init__(self, jids_to_block=None):
+        if jids_to_block is not None:
+            self.items[:] = jids_to_block
+
+    items = aioxmpp.xso.ChildValueList(
+        BlockItemType()
+    )