slidge 0.1.0b2__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_0084 → slixfix/link_preview}/__init__.py

@@ -1,12 +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 . import stanza
-from .avatar import XEP_0084
-from .stanza import Data, MetaData
+from .link_preview import LinkPreview
 
-register_plugin(XEP_0084)
+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

@@ -5,6 +5,7 @@
 import logging
 import ssl
 
+from slixmpp.exceptions import XMPPError
 from slixmpp.plugins import BasePlugin
 from slixmpp.stanza import Iq, StreamFeatures
 from slixmpp.xmlstream import JID, StanzaBase, register_stanza_plugin
@@ -19,7 +20,6 @@ log = logging.getLogger(__name__)
 
 # noinspection PyPep8Naming
 class XEP_0077(BasePlugin):
-
     """
     XEP-0077: In-Band Registration
 
@@ -67,6 +67,7 @@ class XEP_0077(BasePlugin):
         "order": 50,
         "form_fields": {"username", "password"},
         "form_instructions": "Enter your credentials",
+        "enable_subscription": True,
     }
     _user_store: dict[str, dict[str, str]]
 
@@ -79,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,
                 )
             )
@@ -147,6 +148,11 @@ class XEP_0077(BasePlugin):
 
     async def _handle_registration(self, iq: StanzaBase):
         if iq["type"] == "get":
+            if not self.enable_subscription:
+                raise XMPPError(
+                    "bad-request",
+                    text="You must use adhoc commands to register to this gateway.",
+                )
             await self._send_form(iq)
         elif iq["type"] == "set":
             form_dict = iq["register"]["form"].get_values() or iq["register"]
@@ -168,6 +174,12 @@ class XEP_0077(BasePlugin):
                     self.xmpp.event("user_unregister", iq)
                 return
 
+            if not self.enable_subscription:
+                raise XMPPError(
+                    "bad-request",
+                    text="You must use adhoc commands to register to this gateway.",
+                )
+
             if self.form_fields is not None:
                 for field in self.form_fields:
                     if not iq["register"][field]:

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,8 +1,14 @@
 import logging
+import warnings
 
-from slixmpp import JID, Iq, Message, Presence
+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
+
+from . import stanza
+
 log = logging.getLogger(__name__)
 
 
@@ -42,6 +48,8 @@ class XEP_0100(BasePlugin):
 
         self.xmpp.add_event_handler("message", self.on_message)
 
+        register_stanza_plugin(Iq, stanza.Gateway)
+
     def plugin_end(self):
         if not self.xmpp.is_component:
             self.xmpp.remove_event_handler("user_register", self.on_user_register)
@@ -65,10 +73,7 @@ class XEP_0100(BasePlugin):
         await self.add_component_to_roster(jid=iq.get_from())
 
     async def add_component_to_roster(self, jid: JID):
-        try:
-            if self.xmpp.no_roster_push:
-                return
-        except AttributeError:
+        if config.NO_ROSTER_PUSH:
             return
         items = {
             self.xmpp.boundjid.bare: {
@@ -77,18 +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."
-                )
+            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:
@@ -106,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_0100/stanza.py

@@ -0,0 +1,9 @@
+from slixmpp.xmlstream import ElementBase
+
+
+class Gateway(ElementBase):
+    namespace = "jabber:iq:gateway"
+    name = "query"
+    plugin_attrib = "gateway"
+    interfaces = {"desc", "prompt", "jid"}
+    sub_interfaces = interfaces

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")