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

slidge/migration.py

@@ -0,0 +1,18 @@
+import logging
+import shutil
+
+from .core import config
+
+
+def remove_avatar_cache_v1():
+    old_dir = config.HOME_DIR / "slidge_avatars"
+    if old_dir.exists():
+        log.info("Avatar cache dir v1 found, clearing it.")
+        shutil.rmtree(old_dir)
+
+
+def migrate():
+    remove_avatar_cache_v1()
+
+
+log = logging.getLogger(__name__)

slidge/slixfix/__init__.py

@@ -0,0 +1,68 @@
+# This module contains patches for slixmpp; some have pending requests upstream
+# and should be removed on the next slixmpp release.
+
+# ruff: noqa: F401
+
+import slixmpp.plugins
+from slixmpp import Message
+from slixmpp.plugins.xep_0050 import XEP_0050, Command
+from slixmpp.xmlstream import StanzaBase
+
+from . import (  # xep_0356,
+    link_preview,
+    xep_0077,
+    xep_0100,
+    xep_0153,
+    xep_0264,
+    xep_0292,
+    xep_0313,
+    xep_0317,
+    xep_0356_old,
+    xep_0424,
+    xep_0490,
+)
+
+
+def session_bind(self, jid):
+    self.xmpp["xep_0030"].add_feature(Command.namespace)
+    # awful hack to for the disco items: we need to comment this line
+    # related issue: https://todo.sr.ht/~nicoco/slidge/131
+    # self.xmpp['xep_0030'].set_items(node=Command.namespace, items=tuple())
+
+
+XEP_0050.session_bind = session_bind  # type:ignore
+
+
+def reply(self, body=None, clear=True):
+    """
+    Overrides slixmpp's Message.reply(), since it strips to sender's resource
+    for mtype=groupchat, and we do not want that, because when we raise an XMPPError,
+    we actually want to preserve the resource.
+    (this is called in RootStanza.exception() to handle XMPPErrors)
+    """
+    new_message = StanzaBase.reply(self, clear)
+    new_message["thread"] = self["thread"]
+    new_message["parent_thread"] = self["parent_thread"]
+
+    del new_message["id"]
+    if self.stream is not None and self.stream.use_message_ids:
+        new_message["id"] = self.stream.new_id()
+
+    if body is not None:
+        new_message["body"] = body
+    return new_message
+
+
+slixmpp.plugins.PLUGINS.extend(
+    [
+        "link_preview",
+        "xep_0264",
+        "xep_0292_provider",
+        "xep_0317",
+        "xep_0356_old",
+        "xep_0490",
+    ]
+)
+
+
+Message.reply = reply  # type: ignore

slidge/{util/xep_0050 → slixfix/link_preview}/__init__.py

@@ -1,11 +1,10 @@
-
 # Slixmpp: The Slick XMPP Library
-# Copyright (C) 2011 Nathanael C. Fritz, Lance J.T. Stout
+# Copyright (C) 2012 Nathanael C. Fritz, Lance J.T. Stout
 # This file is part of Slixmpp.
 # See the file LICENSE for copying permission.
+
 from slixmpp.plugins.base import register_plugin
 
-from .adhoc import XEP_0050
-from .stanza import Command
+from .link_preview import LinkPreview
 
-register_plugin(XEP_0050)
+register_plugin(LinkPreview)

slidge/slixfix/link_preview/link_preview.py

@@ -0,0 +1,17 @@
+# Slixmpp: The Slick XMPP Library
+# Copyright (C) 2012 Nathanael C. Fritz, Lance J.T. Stout
+# This file is part of Slixmpp.
+# See the file LICENSE for copying permission.
+from slixmpp.plugins import BasePlugin
+
+from . import stanza
+
+
+class LinkPreview(BasePlugin):
+    name = "link_preview"
+    description = "Sender-generated link previews"
+    dependencies = set()
+    stanza = stanza
+
+    def plugin_init(self):
+        stanza.register_plugin()

slidge/slixfix/link_preview/stanza.py

@@ -0,0 +1,99 @@
+# Slixmpp: The Slick XMPP Library
+# Copyright (C) 2012 Nathanael C. Fritz, Lance J.T. Stout
+# This file is part of Slixmpp.
+# See the file LICENSE for copying permission.
+from typing import Optional, Type
+
+from slixmpp.stanza.message import Message
+from slixmpp.xmlstream import ElementBase, register_stanza_plugin
+
+
+class LinkPreview(ElementBase):
+    name = "Description"
+    namespace = "http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+    plugin_attrib = "link_preview"
+    plugin_multi_attrib = "link_previews"
+    interfaces = {"about", "title", "description", "url", "image", "type", "site_name"}
+
+    def _set_og(self, el: ElementBase, value: str) -> None:
+        el.xml.text = value
+        self.xml.append(el.xml)
+
+    def _get_og(self, el: Type[ElementBase]) -> Optional[str]:
+        child = self.xml.find(f"{{{el.namespace}}}{el.name}")
+        if child is None:
+            return None
+        return child.text
+
+    def set_title(self, v: str) -> None:
+        self._set_og(Title(), v)
+
+    def get_title(self) -> Optional[str]:
+        return self._get_og(Title)
+
+    def set_description(self, v: str) -> None:
+        self._set_og(Description(), v)
+
+    def get_description(self) -> Optional[str]:
+        return self._get_og(Description)
+
+    def set_url(self, v: str) -> None:
+        self._set_og(Url(), v)
+
+    def get_url(self) -> Optional[str]:
+        return self._get_og(Url)
+
+    def set_image(self, v: str) -> None:
+        self._set_og(Image(), v)
+
+    def get_image(self) -> Optional[str]:
+        return self._get_og(Image)
+
+    def set_type(self, v: str) -> None:
+        self._set_og(Type_(), v)
+
+    def get_type(self) -> Optional[str]:
+        return self._get_og(Type_)
+
+    def set_site_name(self, v: str) -> None:
+        self._set_og(SiteName(), v)
+
+    def get_site_name(self) -> Optional[str]:
+        return self._get_og(SiteName)
+
+    def get_about(self) -> Optional[str]:
+        return self.xml.attrib.get(f"{{{self.namespace}}}about")
+
+
+class OpenGraphMixin(ElementBase):
+    namespace = "https://ogp.me/ns#"
+
+
+class Title(OpenGraphMixin):
+    name = plugin_attrib = "title"
+
+
+class Description(OpenGraphMixin):
+    name = plugin_attrib = "description"
+
+
+class Url(OpenGraphMixin):
+    name = plugin_attrib = "url"
+
+
+class Image(OpenGraphMixin):
+    name = plugin_attrib = "image"
+
+
+class Type_(OpenGraphMixin):
+    name = plugin_attrib = "type"
+
+
+class SiteName(OpenGraphMixin):
+    name = plugin_attrib = "site_name"
+
+
+def register_plugin():
+    for plugin in Title, Description, Url, Image, Type_, SiteName:
+        register_stanza_plugin(plugin, Title)
+    register_stanza_plugin(Message, LinkPreview, iterable=True)

slidge/slixfix/roster.py

@@ -0,0 +1,60 @@
+from slixmpp import JID
+
+from ..util.db import log, user_store
+
+
+class YesSet(set):
+    """
+    A pseudo-set which always test True for membership
+    """
+
+    def __contains__(self, item):
+        log.debug("Test in")
+        return True
+
+
+class RosterBackend:
+    """
+    A pseudo-roster for the gateway component.
+
+    If a user is in the user store, this will behave as if the user is part of the
+    roster with subscription "both", and "none" otherwise.
+
+    This is rudimentary but the only sane way I could come up with so far.
+    """
+
+    @staticmethod
+    def entries(_owner_jid, _default=None):
+        return YesSet()
+
+    @staticmethod
+    def save(_owner_jid, _jid, _item_state, _db_state):
+        pass
+
+    @staticmethod
+    def load(_owner_jid, jid, _db_state):
+        log.debug("Load %s", jid)
+        user = user_store.get_by_jid(JID(jid))
+        log.debug("User %s", user)
+        if user is None:
+            return {
+                "name": "",
+                "groups": [],
+                "from": False,
+                "to": False,
+                "pending_in": False,
+                "pending_out": False,
+                "whitelisted": False,
+                "subscription": "both",
+            }
+        else:
+            return {
+                "name": "",
+                "groups": [],
+                "from": True,
+                "to": True,
+                "pending_in": False,
+                "pending_out": False,
+                "whitelisted": False,
+                "subscription": "none",
+            }

slidge/{util → slixfix}/xep_0077/register.py

@@ -20,7 +20,6 @@ log = logging.getLogger(__name__)
 
 # noinspection PyPep8Naming
 class XEP_0077(BasePlugin):
-
     """
     XEP-0077: In-Band Registration
 
@@ -81,7 +80,7 @@ class XEP_0077(BasePlugin):
             self.xmpp.register_handler(
                 CoroutineCallback(
                     "registration",
-                    StanzaPath("/iq/register"),
+                    StanzaPath(f"/iq@to={self.xmpp.boundjid.bare}/register"),
                     self._handle_registration,
                 )
             )

slidge/slixfix/xep_0077/stanza.py

@@ -0,0 +1,104 @@
+# Slixmpp: The Slick XMPP Library
+# Copyright (C) 2012 Nathanael C. Fritz, Lance J.T. Stout
+# This file is part of Slixmpp.
+# See the file LICENSE for copying permission.
+from __future__ import unicode_literals
+
+from typing import ClassVar, Set
+
+from slixmpp.xmlstream import ElementBase
+
+
+class Register(ElementBase):
+    namespace = "jabber:iq:register"
+    name = "query"
+    plugin_attrib = "register"
+    interfaces = {
+        "username",
+        "password",
+        "email",
+        "nick",
+        "name",
+        "first",
+        "last",
+        "address",
+        "city",
+        "state",
+        "zip",
+        "phone",
+        "url",
+        "date",
+        "misc",
+        "text",
+        "key",
+        "registered",
+        "remove",
+        "instructions",
+        "fields",
+    }
+    sub_interfaces = interfaces
+    form_fields = {
+        "username",
+        "password",
+        "email",
+        "nick",
+        "name",
+        "first",
+        "last",
+        "address",
+        "city",
+        "state",
+        "zip",
+        "phone",
+        "url",
+        "date",
+        "misc",
+        "text",
+        "key",
+    }
+
+    def get_registered(self):
+        present = self.xml.find("{%s}registered" % self.namespace)
+        return present is not None
+
+    def get_remove(self):
+        present = self.xml.find("{%s}remove" % self.namespace)
+        return present is not None
+
+    def set_registered(self, value):
+        if value:
+            self.add_field("registered")
+        else:
+            del self["registered"]
+
+    def set_remove(self, value):
+        if value:
+            self.add_field("remove")
+        else:
+            del self["remove"]
+
+    def add_field(self, value):
+        self._set_sub_text(value, "", keep=True)
+
+    def get_fields(self):
+        fields = set()
+        for field in self.form_fields:
+            if self.xml.find("{%s}%s" % (self.namespace, field)) is not None:
+                fields.add(field)
+        return fields
+
+    def set_fields(self, fields):
+        del self["fields"]
+        for field in fields:
+            self._set_sub_text(field, "", keep=True)
+
+    def del_fields(self):
+        for field in self.form_fields:
+            self._del_sub(field)
+
+
+class RegisterFeature(ElementBase):
+    name = "register"
+    namespace = "http://jabber.org/features/iq-register"
+    plugin_attrib = name
+    interfaces: ClassVar[Set[str]] = set()

slidge/{util → slixfix}/xep_0100/gateway.py

@@ -1,6 +1,8 @@
 import logging
+import warnings
 
 from slixmpp import JID, Iq, Message, Presence, register_stanza_plugin
+from slixmpp.exceptions import XMPPError
 from slixmpp.plugins.base import BasePlugin
 
 from slidge.core import config
@@ -80,20 +82,21 @@ class XEP_0100(BasePlugin):
                 "groups": ["Slidge"],
             }
         }
+        try:
+            await self._set_roster(jid, items)
+        except PermissionError:
+            warnings.warn(
+                "Slidge does not have the privilege to manage users' rosters. "
+                "Users should add the slidge component to their rosters manually."
+            )
+            if config.ROSTER_PUSH_PRESENCE_SUBSCRIPTION_REQUEST_FALLBACK:
+                self.xmpp.send_presence(ptype="subscribe", pto=jid.bare)
+
+    async def _set_roster(self, jid, items):
         try:
             await self.xmpp["xep_0356"].set_roster(jid=jid.bare, roster_items=items)
         except PermissionError:
-            try:
-                await self.xmpp["xep_0356_old"].set_roster(
-                    jid=jid.bare, roster_items=items
-                )
-            except PermissionError:
-                log.warning(
-                    "Slidge does not have the privilege to manage users' rosters. "
-                    "Users should add the slidge component to their rosters manually."
-                )
-                if config.ROSTER_PUSH_PRESENCE_SUBSCRIPTION_REQUEST_FALLBACK:
-                    self.xmpp.send_presence(ptype="subscribe", pto=jid.bare)
+            await self.xmpp["xep_0356_old"].set_roster(jid=jid.bare, roster_items=items)
 
     def on_presence_unsubscribe(self, p: Presence):
         if p.get_to() == self.xmpp.boundjid.bare:
@@ -111,6 +114,8 @@ class XEP_0100(BasePlugin):
             return
 
         if self.needs_registration and await self.get_user(msg) is None:
-            return
+            raise XMPPError(
+                "registration-required", text="You are not registered to this gateway"
+            )
 
         self.xmpp.event("legacy_message", msg)

slidge/slixfix/xep_0153/__init__.py

@@ -0,0 +1,10 @@
+# Slixmpp: The Slick XMPP Library
+# Copyright (C) 2012 Nathanael C. Fritz, Lance J.T. Stout
+# This file is part of Slixmpp.
+# See the file LICENSE for copying permission.
+from slixmpp.plugins.base import register_plugin
+
+from .stanza import VCardTempUpdate
+from .vcard_avatar import XEP_0153
+
+register_plugin(XEP_0153)

slidge/slixfix/xep_0153/stanza.py

@@ -0,0 +1,25 @@
+# Slixmpp: The Slick XMPP Library
+# Copyright (C) 2012 Nathanael C. Fritz, Lance J.T. Stout
+# This file is part of Slixmpp.
+# See the file LICENSE for copying permission.
+from slixmpp.xmlstream import ElementBase
+
+
+class VCardTempUpdate(ElementBase):
+    name = "x"
+    namespace = "vcard-temp:x:update"
+    plugin_attrib = "vcard_temp_update"
+    interfaces = {"photo"}
+    sub_interfaces = interfaces
+
+    def set_photo(self, value):
+        if value is not None:
+            self._set_sub_text("photo", value, keep=True)
+        else:
+            self._del_sub("photo")
+
+    def get_photo(self):
+        photo = self.xml.find("{%s}photo" % self.namespace)
+        if photo is None:
+            return None
+        return photo.text

slidge/slixfix/xep_0153/vcard_avatar.py

@@ -0,0 +1,23 @@
+# Slixmpp: The Slick XMPP Library
+# Copyright (C) 2012 Nathanael C. Fritz, Lance J.T. Stout
+# This file is part of Slixmpp.
+# See the file LICENSE for copying permission.
+import logging
+
+from slixmpp.plugins.base import BasePlugin
+from slixmpp.stanza import Presence
+from slixmpp.xmlstream import register_stanza_plugin
+
+from . import VCardTempUpdate, stanza
+
+log = logging.getLogger(__name__)
+
+
+class XEP_0153(BasePlugin):
+    name = "xep_0153"
+    description = "XEP-0153: vCard-Based Avatars (slidge, just for MUCs)"
+    dependencies = {"xep_0054"}
+    stanza = stanza
+
+    def plugin_init(self):
+        register_stanza_plugin(Presence, VCardTempUpdate)

slidge/slixfix/xep_0264/__init__.py

@@ -0,0 +1,5 @@
+from slixmpp.plugins.base import register_plugin
+
+from .thumbnail import XEP_0264
+
+register_plugin(XEP_0264)

slidge/slixfix/xep_0264/stanza.py

@@ -0,0 +1,36 @@
+from typing import Optional
+
+from slixmpp import register_stanza_plugin
+from slixmpp.plugins.xep_0234.stanza import File
+from slixmpp.xmlstream import ElementBase
+
+NS = "urn:xmpp:thumbs:1"
+
+
+class Thumbnail(ElementBase):
+    name = plugin_attrib = "thumbnail"
+    namespace = NS
+    interfaces = {"uri", "media-type", "width", "height"}
+
+    def get_width(self) -> float:
+        return _int_or_none(self._get_attr("width"))
+
+    def get_height(self) -> float:
+        return _int_or_none(self._get_attr("height"))
+
+    def set_width(self, v: int) -> None:
+        self._set_attr("width", str(v))
+
+    def set_height(self, v: int) -> None:
+        self._set_attr("height", str(v))
+
+
+def _int_or_none(v) -> Optional[int]:
+    try:
+        return int(v)
+    except ValueError:
+        return None
+
+
+def register_plugin():
+    register_stanza_plugin(File, Thumbnail)

slidge/slixfix/xep_0264/thumbnail.py

@@ -0,0 +1,23 @@
+import logging
+
+from slixmpp.plugins import BasePlugin
+
+from . import stanza
+
+log = logging.getLogger(__name__)
+
+
+class XEP_0264(BasePlugin):
+    """
+    XEP-0264: Jingle Content Thumbnails
+
+    Minimum needed for xep 0385 (Stateless inline media sharing)
+    """
+
+    name = "xep_0264"
+    description = "XEP-0264: Jingle Content Thumbnails"
+    dependencies = {"xep_0234"}
+    stanza = stanza
+
+    def plugin_init(self):
+        stanza.register_plugin()

slidge/slixfix/xep_0292/__init__.py

@@ -0,0 +1,5 @@
+from slixmpp.plugins.xep_0292 import stanza
+
+from . import vcard4
+
+__all__ = ("stanza", "vcard4")

slidge/slixfix/xep_0292/vcard4.py

@@ -0,0 +1,100 @@
+import logging
+from typing import TYPE_CHECKING, NamedTuple, Optional
+
+from slixmpp import JID, CoroutineCallback, Iq, StanzaPath
+from slixmpp.plugins.base import BasePlugin, register_plugin
+from slixmpp.plugins.xep_0292.stanza import NS, VCard4
+from slixmpp.types import JidStr
+
+from slidge.contact import LegacyContact
+
+if TYPE_CHECKING:
+    from slidge.core.gateway import BaseGateway
+
+
+class StoredVCard(NamedTuple):
+    content: VCard4
+    authorized_jids: set[JidStr]
+
+
+class VCard4Provider(BasePlugin):
+    xmpp: "BaseGateway"
+
+    name = "xep_0292_provider"
+    description = "VCard4 Provider"
+    dependencies = {"xep_0030"}
+
+    def __init__(self, *a, **k):
+        super(VCard4Provider, self).__init__(*a, **k)
+        self._vcards = dict[JidStr, StoredVCard]()
+
+    def plugin_init(self):
+        self.xmpp.register_handler(
+            CoroutineCallback(
+                "get_vcard",
+                StanzaPath(f"iq@type=get/vcard"),
+                self.handle_vcard_get,  # type:ignore
+            )
+        )
+
+        self.xmpp.plugin["xep_0030"].add_feature(NS)
+
+    def _get_cached_vcard(self, jid: JidStr, requested_by: JidStr) -> Optional[VCard4]:
+        vcard = self._vcards.get(JID(jid).bare)
+        if vcard:
+            if auth := vcard.authorized_jids:
+                if JID(requested_by).bare in auth:
+                    return vcard.content
+            else:
+                return vcard.content
+        return None
+
+    async def get_vcard(self, jid: JidStr, requested_by: JidStr) -> Optional[VCard4]:
+        if vcard := self._get_cached_vcard(jid, requested_by):
+            log.debug("Found a cached vcard")
+            return vcard
+        if not hasattr(self.xmpp, "get_session_from_jid"):
+            return None
+        jid = JID(jid)
+        requested_by = JID(requested_by)
+        session = self.xmpp.get_session_from_jid(requested_by)
+        if session is None:
+            return
+        entity = await session.get_contact_or_group_or_participant(jid)
+        if isinstance(entity, LegacyContact):
+            log.debug("Fetching vcard")
+            await entity.fetch_vcard()
+            return self._get_cached_vcard(jid, requested_by)
+        return None
+
+    async def handle_vcard_get(self, iq: Iq):
+        r = iq.reply()
+        if vcard := await self.get_vcard(iq.get_to().bare, iq.get_from().bare):
+            r.append(vcard)
+        else:
+            r.enable("vcard")
+        r.send()
+
+    def set_vcard(
+        self,
+        jid: JidStr,
+        vcard: VCard4,
+        /,
+        authorized_jids: Optional[set[JidStr]] = None,
+    ):
+        cache = self._vcards.get(jid)
+        new = StoredVCard(
+            vcard, authorized_jids if authorized_jids is not None else set()
+        )
+        self._vcards[jid] = new
+        if cache == new:
+            return
+        if self.xmpp["pubsub"] and authorized_jids:
+            for to in authorized_jids:
+                self.xmpp.loop.create_task(
+                    self.xmpp["pubsub"].broadcast_vcard_event(jid, to)
+                )
+
+
+register_plugin(VCard4Provider)
+log = logging.getLogger(__name__)