slidge 0.1.0__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/slixfix/link_preview/__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 .link_preview import LinkPreview
+
+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/slixfix/xep_0077/__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 .register import XEP_0077
+from .stanza import Register, RegisterFeature
+
+register_plugin(XEP_0077)

slidge/slixfix/xep_0077/register.py

@@ -0,0 +1,289 @@
+# 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
+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
+from slixmpp.xmlstream.handler import CoroutineCallback
+from slixmpp.xmlstream.matcher import StanzaPath
+
+from . import stanza
+from .stanza import Register, RegisterFeature
+
+log = logging.getLogger(__name__)
+
+
+# noinspection PyPep8Naming
+class XEP_0077(BasePlugin):
+    """
+    XEP-0077: In-Band Registration
+
+    Events:
+
+    ::
+
+        user_register           -- After successful validation and add to the user store
+                                   in api["user_validate"]
+        user_unregister         -- After successful user removal in api["user_remove"]
+        user_modify             -- After successful user modify in api["user_modify"]
+
+    Config:
+
+    ::
+
+        form_fields and form_instructions are only used if api["make_registration_form"] is
+        not overridden; in this case form_fields MUST be None
+
+    API:
+
+    ::
+
+        user_get(jid, node, ifrom, iq)
+            Returns a dict-like object containing `form_fields` for this user or None
+        user_remove(jid, node, ifrom, iq)
+            Removes a user or raise KeyError in case the user is not found in the user store
+        make_registration_form(self, jid, node, ifrom, iq)
+            Returns an iq reply to a registration form request, pre-filled and with
+            <registered/> in case the requesting entity is already registered to us
+        user_validate((self, jid, node, ifrom, registration)
+            Add the user to the user store or raise ValueError(msg) if any problem is encountered
+            msg is sent back to the XMPP client as an error message.
+        user_modify(jid, node, ifrom, iq)
+            Modify the user in the user store or raise ValueError(msg) (similarly to user_validate)
+    """
+
+    name = "xep_0077"
+    description = "XEP-0077: In-Band Registration (slidge)"
+    dependencies = {"xep_0004", "xep_0066"}
+    stanza = stanza
+    default_config = {
+        "create_account": True,
+        "force_registration": False,
+        "order": 50,
+        "form_fields": {"username", "password"},
+        "form_instructions": "Enter your credentials",
+        "enable_subscription": True,
+    }
+    _user_store: dict[str, dict[str, str]]
+
+    def plugin_init(self):
+        register_stanza_plugin(StreamFeatures, RegisterFeature)
+        register_stanza_plugin(Iq, Register)
+
+        if self.xmpp.is_component:
+            self.xmpp["xep_0030"].add_feature("jabber:iq:register")
+            self.xmpp.register_handler(
+                CoroutineCallback(
+                    "registration",
+                    StanzaPath(f"/iq@to={self.xmpp.boundjid.bare}/register"),
+                    self._handle_registration,
+                )
+            )
+            self._user_store = {}
+            self.api.register(self._user_get, "user_get")
+            self.api.register(self._user_remove, "user_remove")
+            self.api.register(self._user_modify, "user_modify")
+            self.api.register(self._make_registration_form, "make_registration_form")
+            self.api.register(self._user_validate, "user_validate")
+        else:
+            self.xmpp.register_feature(
+                "register",
+                self._handle_register_feature,
+                restart=False,
+                order=self.order,
+            )
+
+        register_stanza_plugin(Register, self.xmpp["xep_0004"].stanza.Form)
+        register_stanza_plugin(Register, self.xmpp["xep_0066"].stanza.OOB)
+
+        self.xmpp.add_event_handler("connected", self._force_registration)
+
+    def plugin_end(self):
+        if not self.xmpp.is_component:
+            self.xmpp.unregister_feature("register", self.order)
+
+    def _user_get(self, _jid, _node, _ifrom, iq):
+        return self._user_store.get(iq["from"].bare)
+
+    def _user_remove(self, _jid, _node, _ifrom, iq):
+        return self._user_store.pop(iq["from"].bare)
+
+    async def _make_registration_form(self, _jid, _node, _ifrom, iq: Iq):
+        reg = iq["register"]
+        user = await self.api["user_get"](None, None, iq["from"], iq)
+
+        if user is None:
+            user = {}
+        else:
+            reg["registered"] = True
+
+        reg["instructions"] = self.form_instructions
+
+        for field in self.form_fields:
+            data = user.get(field, "")
+            if data:
+                reg[field] = data
+            else:
+                # Add a blank field
+                reg.add_field(field)
+
+        reply = iq.reply()
+        reply.set_payload(reg.xml)
+        return reply
+
+    def _user_validate(self, _jid, _node, ifrom, registration):
+        self._user_store[ifrom.bare] = {
+            key: registration[key] for key in self.form_fields
+        }
+
+    def _user_modify(self, _jid, _node, ifrom, registration):
+        self._user_store[ifrom.bare] = {
+            key: registration[key] for key in self.form_fields
+        }
+
+    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"]
+
+            if form_dict.get("remove"):
+                try:
+                    await self.api["user_remove"](None, None, iq["from"], iq)
+                except KeyError:
+                    _send_error(
+                        iq,
+                        "404",
+                        "cancel",
+                        "item-not-found",
+                        "User not found",
+                    )
+                else:
+                    reply = iq.reply()
+                    reply.send()
+                    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]:
+                        # Incomplete Registration
+                        _send_error(
+                            iq,
+                            "406",
+                            "modify",
+                            "not-acceptable",
+                            "Please fill in all fields.",
+                        )
+                        return
+
+            user = await self.api["user_get"](None, None, iq["from"], iq)
+
+            try:
+                if user is None:
+                    await self.api["user_validate"](None, None, iq["from"], form_dict)
+                else:
+                    await self.api["user_modify"](None, None, iq["from"], form_dict)
+            except ValueError as e:
+                _send_error(iq, "406", "modify", "not-acceptable", "\n".join(e.args))
+                return
+
+            reply = iq.reply()
+            reply.send()
+
+            if user is None:
+                self.xmpp.event("user_register", iq)
+            else:
+                self.xmpp.event("user_modify", iq)
+
+    async def _send_form(self, iq):
+        reply = await self.api["make_registration_form"](None, None, iq["from"], iq)
+        reply.send()
+
+    def _force_registration(self, _event):
+        if self.force_registration:
+            self.xmpp.add_filter("in", self._force_stream_feature)
+
+    def _force_stream_feature(self, stanza_):
+        if isinstance(stanza_, StreamFeatures):
+            if not self.xmpp.disable_starttls:
+                if "starttls" not in self.xmpp.features:
+                    return stanza_
+                elif not isinstance(self.xmpp.socket, ssl.SSLSocket):
+                    return stanza_
+            if "mechanisms" not in self.xmpp.features:
+                log.debug("Forced adding in-band registration stream feature")
+                stanza_.enable("register")
+                self.xmpp.del_filter("in", self._force_stream_feature)
+        return stanza_
+
+    async def _handle_register_feature(self, _features):
+        if "mechanisms" in self.xmpp.features:
+            # We have already logged in with an account
+            return False
+
+        if self.create_account and self.xmpp.event_handled("register"):
+            form = await self.get_registration()
+            await self.xmpp.event_async("register", form)
+            return True
+        return False
+
+    def get_registration(self, jid=None, ifrom=None, timeout=None, callback=None):
+        iq = self.xmpp.Iq()
+        iq["type"] = "get"
+        iq["to"] = jid
+        iq["from"] = ifrom
+        iq.enable("register")
+        return iq.send(timeout=timeout, callback=callback)
+
+    def cancel_registration(self, jid=None, ifrom=None, timeout=None, callback=None):
+        iq = self.xmpp.Iq()
+        iq["type"] = "set"
+        iq["to"] = jid
+        iq["from"] = ifrom
+        iq["register"]["remove"] = True
+        return iq.send(timeout=timeout, callback=callback)
+
+    def change_password(
+        self, password, jid=None, ifrom=None, timeout=None, callback=None
+    ):
+        iq = self.xmpp.Iq()
+        iq["type"] = "set"
+        iq["to"] = jid
+        iq["from"] = ifrom
+        if self.xmpp.is_component:
+            ifrom = JID(ifrom)
+            iq["register"]["username"] = ifrom.user
+        else:
+            iq["register"]["username"] = self.xmpp.boundjid.user
+        iq["register"]["password"] = password
+        return iq.send(timeout=timeout, callback=callback)
+
+
+def _send_error(iq, code, error_type, name, text=""):
+    # It would be nice to raise XMPPError but the iq payload
+    # should include the register info
+    reply = iq.reply()
+    reply.set_payload(iq["register"].xml)
+    reply.error()
+    reply["error"]["code"] = code
+    reply["error"]["type"] = error_type
+    reply["error"]["condition"] = name
+    reply["error"]["text"] = text
+    reply.send()

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/slixfix/xep_0100/__init__.py

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