slidge 0.1.0__py3-none-any.whl

slidge/slixfix/xep_0424/retraction.py

@@ -0,0 +1,77 @@
+# Slixmpp: The Slick XMPP Library
+# Copyright (C) 2020 Mathieu Pasquet <mathieui@mathieui.net>
+# This file is part of Slixmpp.
+# See the file LICENSE for copying permission.
+from typing import Optional
+
+from slixmpp import JID, Message
+from slixmpp.exceptions import IqError, IqTimeout
+from slixmpp.plugins import BasePlugin
+from slixmpp.xmlstream.handler import Callback
+from slixmpp.xmlstream.matcher import StanzaPath
+
+from . import stanza
+
+DEFAULT_FALLBACK = (
+    "This person attempted to retract a previous message, but your client "
+    "does not support it."
+)
+
+
+class XEP_0424(BasePlugin):
+    """XEP-0424: Message Retraction"""
+
+    name = "xep_0424"
+    description = "XEP-0424: Message Retraction (fix Slidge)"
+    dependencies = {"xep_0422", "xep_0030", "xep_0359", "xep_0428", "xep_0334"}
+    stanza = stanza
+    namespace = stanza.NS
+
+    def plugin_init(self) -> None:
+        stanza.register_plugins()
+        self.xmpp.register_handler(
+            Callback(
+                "Message Retracted",
+                StanzaPath("message/retract"),
+                self._handle_retract_message,
+            )
+        )
+
+    def session_bind(self, jid):
+        self.xmpp.plugin["xep_0030"].add_feature(feature=stanza.NS)
+
+    def plugin_end(self):
+        self.xmpp.plugin["xep_0030"].del_feature(feature=stanza.NS)
+
+    def _handle_retract_message(self, message: Message):
+        self.xmpp.event("message_retract", message)
+
+    def send_retraction(
+        self,
+        mto: JID,
+        id: str,
+        mtype: str = "chat",
+        include_fallback: bool = True,
+        fallback_text: Optional[str] = None,
+        *,
+        mfrom: Optional[JID] = None
+    ):
+        """
+        Send a message retraction
+
+        :param JID mto: The JID to retract the message from
+        :param str id: Message ID to retract
+        :param str mtype: Message type
+        :param bool include_fallback: Whether to include a fallback body
+        :param Optional[str] fallback_text: The content of the fallback
+                                            body. None will set the default value.
+        """
+        if fallback_text is None:
+            fallback_text = DEFAULT_FALLBACK
+        msg = self.xmpp.make_message(mto=mto, mtype=mtype, mfrom=mfrom)
+        if include_fallback:
+            msg["body"] = fallback_text
+            msg.enable("fallback")
+        msg["retract"]["id"] = id
+        msg.enable("store")
+        msg.send()

slidge/slixfix/xep_0424/stanza.py

@@ -0,0 +1,28 @@
+# Slixmpp: The Slick XMPP Library
+# Copyright (C) 2020 Mathieu Pasquet <mathieui@mathieui.net>
+# This file is part of Slixmpp.
+# See the file LICENSE for copying permissio
+from slixmpp.plugins.xep_0359 import OriginID
+from slixmpp.stanza import Message
+from slixmpp.xmlstream import ElementBase, register_stanza_plugin
+
+NS = "urn:xmpp:message-retract:1"
+
+
+class Retract(ElementBase):
+    namespace = NS
+    name = "retract"
+    plugin_attrib = "retract"
+
+
+class Retracted(ElementBase):
+    namespace = NS
+    name = "retracted"
+    plugin_attrib = "retracted"
+    interfaces = {"stamp"}
+
+
+def register_plugins():
+    register_stanza_plugin(Message, Retract)
+    register_stanza_plugin(Message, Retracted)
+    register_stanza_plugin(Retracted, OriginID)

slidge/slixfix/xep_0490/__init__.py

@@ -0,0 +1,8 @@
+from slixmpp.plugins.base import register_plugin
+
+from . import stanza
+from .mds import XEP_0490
+
+register_plugin(XEP_0490)
+
+__all__ = ["stanza", "XEP_0490"]

slidge/slixfix/xep_0490/mds.py

@@ -0,0 +1,47 @@
+from slixmpp import Iq
+from slixmpp.plugins import BasePlugin
+from slixmpp.plugins.xep_0004 import Form
+from slixmpp.types import JidStr
+
+from . import stanza
+
+
+class XEP_0490(BasePlugin):
+    """
+    XEP-0490: Message Displayed Synchronization
+    """
+
+    name = "xep_0490"
+    description = "XEP-0490: Message Displayed Synchronization"
+    dependencies = {"xep_0060", "xep_0163", "xep_0359"}
+    stanza = stanza
+
+    def plugin_init(self):
+        stanza.register_plugin()
+        self.xmpp.plugin["xep_0163"].register_pep(
+            "message_displayed_synchronization",
+            stanza.Displayed,
+        )
+
+    def flag_chat(self, chat: JidStr, stanza_id: str, **kwargs) -> Iq:
+        displayed = stanza.Displayed()
+        displayed["stanza_id"]["id"] = stanza_id
+        return self.xmpp.plugin["xep_0163"].publish(
+            displayed, node=stanza.NS, options=PUBLISH_OPTIONS, id=str(chat), **kwargs
+        )
+
+    def catch_up(self, **kwargs):
+        return self.xmpp.plugin["xep_0060"].get_items(
+            self.xmpp.boundjid.bare, stanza.NS, **kwargs
+        )
+
+
+PUBLISH_OPTIONS = Form()
+PUBLISH_OPTIONS["type"] = "submit"
+PUBLISH_OPTIONS.add_field(
+    "FORM_TYPE", "hidden", value="http://jabber.org/protocol/pubsub#publish-options"
+)
+PUBLISH_OPTIONS.add_field("pubsub#persist_items", value="true")
+PUBLISH_OPTIONS.add_field("pubsub#max_items", value="max")
+PUBLISH_OPTIONS.add_field("pubsub#send_last_published_item", value="never")
+PUBLISH_OPTIONS.add_field("pubsub#access_model", value="whitelist")

slidge/slixfix/xep_0490/stanza.py

@@ -0,0 +1,17 @@
+from slixmpp import register_stanza_plugin
+from slixmpp.plugins.xep_0060.stanza import Item
+from slixmpp.plugins.xep_0359.stanza import StanzaID
+from slixmpp.xmlstream import ElementBase
+
+NS = "urn:xmpp:mds:displayed:0"
+
+
+class Displayed(ElementBase):
+    namespace = NS
+    name = "displayed"
+    plugin_attrib = "displayed"
+
+
+def register_plugin():
+    register_stanza_plugin(Displayed, StanzaID)
+    register_stanza_plugin(Item, Displayed)

slidge/util/__init__.py

@@ -0,0 +1,15 @@
+from .util import (
+    ABCSubclassableOnceAtMost,
+    SubclassableOnce,
+    is_valid_phone_number,
+    replace_mentions,
+    strip_illegal_chars,
+)
+
+__all__ = [
+    "SubclassableOnce",
+    "ABCSubclassableOnceAtMost",
+    "is_valid_phone_number",
+    "replace_mentions",
+    "strip_illegal_chars",
+]

slidge/util/archive_msg.py

@@ -0,0 +1,61 @@
+from copy import copy
+from datetime import datetime, timezone
+from typing import Optional, Union
+from xml.etree import ElementTree as ET
+
+from slixmpp import Message
+from slixmpp.plugins.xep_0297 import Forwarded
+
+
+def fix_namespaces(xml, old="{jabber:component:accept}", new="{jabber:client}"):
+    """
+    Hack to fix namespaces between jabber:component and jabber:client
+
+    Acts in-place.
+
+    :param xml:
+    :param old:
+    :param new:
+    """
+    xml.tag = xml.tag.replace(old, new)
+    for child in xml:
+        fix_namespaces(child, old, new)
+
+
+class HistoryMessage:
+    def __init__(self, stanza: Union[Message, str], when: Optional[datetime] = None):
+        if isinstance(stanza, str):
+            from_db = True
+            stanza = Message(xml=ET.fromstring(stanza))
+        else:
+            from_db = False
+
+        self.id = stanza["stanza_id"]["id"]
+        self.when: datetime = (
+            when or stanza["delay"]["stamp"] or datetime.now(tz=timezone.utc)
+        )
+
+        if not from_db:
+            del stanza["delay"]
+            del stanza["markable"]
+            del stanza["hint"]
+            del stanza["chat_state"]
+            if not stanza["body"]:
+                del stanza["body"]
+            fix_namespaces(stanza.xml)
+
+        self.stanza: Message = stanza
+
+    @property
+    def stanza_component_ns(self):
+        stanza = copy(self.stanza)
+        fix_namespaces(
+            stanza.xml, old="{jabber:client}", new="{jabber:component:accept}"
+        )
+        return stanza
+
+    def forwarded(self):
+        forwarded = Forwarded()
+        forwarded["delay"]["stamp"] = self.when
+        forwarded.append(self.stanza)
+        return forwarded

slidge/util/conf.py

@@ -0,0 +1,206 @@
+import logging
+from functools import cached_property
+from types import GenericAlias
+from typing import Optional, Union, get_args, get_origin, get_type_hints
+
+import configargparse
+
+
+class Option:
+    DOC_SUFFIX = "__DOC"
+    DYNAMIC_DEFAULT_SUFFIX = "__DYNAMIC_DEFAULT"
+    SHORT_SUFFIX = "__SHORT"
+
+    def __init__(self, parent: "ConfigModule", name: str):
+        self.parent = parent
+        self.config_obj = parent.config_obj
+        self.name = name
+
+    @cached_property
+    def doc(self):
+        return getattr(self.config_obj, self.name + self.DOC_SUFFIX)
+
+    @cached_property
+    def required(self):
+        return not hasattr(
+            self.config_obj, self.name + self.DYNAMIC_DEFAULT_SUFFIX
+        ) and not hasattr(self.config_obj, self.name)
+
+    @cached_property
+    def default(self):
+        return getattr(self.config_obj, self.name, None)
+
+    @cached_property
+    def short(self):
+        return getattr(self.config_obj, self.name + self.SHORT_SUFFIX, None)
+
+    @cached_property
+    def nargs(self):
+        type_ = get_type_hints(self.config_obj).get(self.name, type(self.default))
+
+        if isinstance(type_, GenericAlias):
+            args = get_args(type_)
+            if args[1] is Ellipsis:
+                return "*"
+            else:
+                return len(args)
+
+    @cached_property
+    def type(self):
+        type_ = get_type_hints(self.config_obj).get(self.name, type(self.default))
+
+        if _is_optional(type_):
+            type_ = get_args(type_)[0]
+        elif isinstance(type_, GenericAlias):
+            args = get_args(type_)
+            type_ = args[0]
+
+        return type_
+
+    @cached_property
+    def names(self):
+        res = ["--" + self.name.lower().replace("_", "-")]
+        if s := self.short:
+            res.append("-" + s)
+        return res
+
+    @cached_property
+    def kwargs(self):
+        kwargs = dict(
+            required=self.required,
+            help=self.doc,
+            env_var=self.name_to_env_var(),
+        )
+        t = self.type
+        if t is bool:
+            if self.default:
+                kwargs["action"] = "store_false"
+            else:
+                kwargs["action"] = "store_true"
+        else:
+            kwargs["type"] = t
+            if self.required:
+                kwargs["required"] = True
+            else:
+                kwargs["default"] = self.default
+        if n := self.nargs:
+            kwargs["nargs"] = n
+        return kwargs
+
+    def name_to_env_var(self):
+        return self.parent.ENV_VAR_PREFIX + self.name
+
+
+class ConfigModule:
+    ENV_VAR_PREFIX = "SLIDGE_"
+
+    def __init__(
+        self, config_obj, parser: Optional[configargparse.ArgumentParser] = None
+    ):
+        self.config_obj = config_obj
+        if parser is None:
+            parser = configargparse.ArgumentParser()
+        self.parser = parser
+
+        self.add_options_to_parser()
+
+    def _list_options(self):
+        return {
+            o
+            for o in (set(dir(self.config_obj)) | set(get_type_hints(self.config_obj)))
+            if o.upper() == o and not o.startswith("_") and "__" not in o
+        }
+
+    def set_conf(self, argv: Optional[list[str]] = None):
+        if argv is not None:
+            # this is ugly, but necessary because for plugin config, we used
+            # remaining argv.
+            # when using (a) .ini file(s), for bool options, we end-up with
+            # remaining pseudo-argv such as --some-bool-opt=true when we really
+            # should have just --some-bool-opt
+            # TODO: get rid of configargparse and make this cleaner
+            options_long = {o.name: o for o in self.options}
+            no_explicit_bool = []
+            skip_next = False
+            for a, aa in zip(argv, argv[1:] + [""]):
+                if skip_next:
+                    skip_next = False
+                    continue
+                force_keep = False
+                if "=" in a:
+                    real_name, _value = a.split("=")
+                    opt: Optional[Option] = options_long.get(
+                        _argv_to_option_name(real_name)
+                    )
+                    if opt and opt.type is bool:
+                        if opt.default:
+                            if _value in _TRUEISH or not _value:
+                                continue
+                            else:
+                                a = real_name
+                                force_keep = True
+                        else:
+                            if _value in _TRUEISH:
+                                a = real_name
+                                force_keep = True
+                            else:
+                                continue
+                else:
+                    upper = _argv_to_option_name(a)
+                    opt = options_long.get(upper)
+                    if opt and opt.type is bool:
+                        if _argv_to_option_name(aa) not in options_long:
+                            log.debug("Removing %s from argv", aa)
+                            skip_next = True
+
+                if opt:
+                    if opt.type is bool:
+                        if force_keep or not opt.default:
+                            no_explicit_bool.append(a)
+                    else:
+                        no_explicit_bool.append(a)
+                else:
+                    no_explicit_bool.append(a)
+            log.debug("Removed boolean values from %s to %s", argv, no_explicit_bool)
+            argv = no_explicit_bool
+
+        args, rest = self.parser.parse_known_args(argv)
+        self.update_dynamic_defaults(args)
+        for name in self._list_options():
+            value = getattr(args, name.lower())
+            log.debug("Setting '%s' to %r", name, value)
+            setattr(self.config_obj, name, value)
+        return args, rest
+
+    @cached_property
+    def options(self) -> list[Option]:
+        res = []
+        for opt in self._list_options():
+            res.append(Option(self, opt))
+        return res
+
+    def add_options_to_parser(self):
+        p = self.parser
+        for o in sorted(self.options, key=lambda x: (not x.required, x.name)):
+            p.add_argument(*o.names, **o.kwargs)
+
+    def update_dynamic_defaults(self, args):
+        pass
+
+
+def _is_optional(t):
+    if get_origin(t) is Union:
+        args = get_args(t)
+        if len(args) == 2 and isinstance(None, args[1]):
+            return True
+    return False
+
+
+def _argv_to_option_name(arg: str):
+    return arg.upper().removeprefix("--").replace("-", "_")
+
+
+_TRUEISH = {"true", "True", "1", "on", "enabled"}
+
+
+log = logging.getLogger(__name__)

slidge/util/db.py

@@ -0,0 +1,229 @@
+"""
+This module covers a backend for storing user data persistently and managing a
+pseudo-roster for the gateway component.
+"""
+
+import dataclasses
+import datetime
+import logging
+import os.path
+import shelve
+from io import BytesIO
+from os import PathLike
+from typing import Iterable, Optional, Union
+
+from pickle_secure import Pickler, Unpickler
+from slixmpp import JID, Iq, Message, Presence
+
+from .sql import db
+
+
+# noinspection PyUnresolvedReferences
+class EncryptedShelf(shelve.DbfilenameShelf):
+    cache: dict
+    dict: dict
+    writeback: bool
+    keyencoding: str
+    _protocol: int
+
+    def __init__(
+        self, filename: PathLike, key: str, flag="c", protocol=None, writeback=False
+    ):
+        super().__init__(str(filename), flag, protocol, writeback)
+        self.secret_key = key
+
+    def __getitem__(self, key):
+        try:
+            value = self.cache[key]
+        except KeyError:
+            f = BytesIO(self.dict[key.encode(self.keyencoding)])
+            value = Unpickler(f, key=self.secret_key).load()  # type:ignore
+            if self.writeback:
+                self.cache[key] = value
+        return value
+
+    def __setitem__(self, key, value):
+        if self.writeback:
+            self.cache[key] = value
+        f = BytesIO()
+        p = Pickler(f, self._protocol, key=self.secret_key)  # type:ignore
+        p.dump(value)
+        self.dict[key.encode(self.keyencoding)] = f.getvalue()
+
+
+@dataclasses.dataclass
+class GatewayUser:
+    """
+    A gateway user
+    """
+
+    bare_jid: str
+    """Bare JID of the user"""
+    registration_form: dict[str, Optional[str]]
+    """Content of the registration form, as a dict"""
+    plugin_data: Optional[dict] = None
+    registration_date: Optional[datetime.datetime] = None
+
+    def __hash__(self):
+        return hash(self.bare_jid)
+
+    def __repr__(self):
+        return f"<User {self.bare_jid}>"
+
+    def __post_init__(self):
+        if self.registration_date is None:
+            self.registration_date = datetime.datetime.now()
+
+    @property
+    def jid(self) -> JID:
+        """
+        The user's (bare) JID
+
+        :return:
+        """
+        return JID(self.bare_jid)
+
+    def get(self, field: str, default: str = "") -> Optional[str]:
+        # """
+        # Get fields from the registration form (required to comply with slixmpp backend protocol)
+        #
+        # :param field: Name of the field
+        # :param default: Default value to return if the field is not present
+        #
+        # :return: Value of the field
+        # """
+        return self.registration_form.get(field, default)
+
+    def commit(self):
+        db.user_store(self)
+        user_store.commit(self)
+
+
+class UserStore:
+    """
+    Basic user store implementation using shelve from the python standard library
+
+    Set_file must be called before it is usable
+    """
+
+    def __init__(self):
+        self._users: shelve.Shelf[GatewayUser] = None  # type: ignore
+
+    def set_file(self, filename: PathLike, secret_key: Optional[str] = None):
+        """
+        Set the file to use to store user data
+
+        :param filename: Path to the shelf file
+        :param secret_key: Secret key to store files encrypted on disk
+        """
+        if self._users is not None:
+            raise RuntimeError("Shelf file already set!")
+        if os.path.exists(filename):
+            log.info("Using existing slidge DB: %s", filename)
+        else:
+            log.info("Creating a new slidge DB: %s", filename)
+        if secret_key:
+            self._users = EncryptedShelf(filename, key=secret_key)
+        else:
+            self._users = shelve.open(str(filename))
+        for user in self._users.values():
+            db.user_store(user)
+        log.info("Registered users in the DB: %s", list(self._users.keys()))
+
+    def get_all(self) -> Iterable[GatewayUser]:
+        """
+        Get all users in the store
+
+        :return: An iterable of GatewayUsers
+        """
+        return self._users.values()
+
+    def add(self, jid: JID, registration_form: dict[str, Optional[str]]):
+        """
+        Add a user to the store.
+
+        NB: there is no reason to call this manually, as this should be covered
+        by slixmpp XEP-0077 and XEP-0100 plugins
+
+        :param jid: JID of the gateway user
+        :param registration_form: Content of the registration form (:xep:`0077`)
+        """
+        log.debug("Adding user %s", jid)
+        self._users[jid.bare] = user = GatewayUser(
+            bare_jid=jid.bare,
+            registration_form=registration_form,
+            registration_date=datetime.datetime.now(),
+        )
+        self._users.sync()
+        user.commit()
+        log.debug("Store: %s", self._users)
+
+    def commit(self, user: GatewayUser):
+        self._users[user.bare_jid] = user
+        self._users.sync()
+
+    def get(self, _gateway_jid, _node, ifrom: JID, iq) -> Optional[GatewayUser]:
+        """
+        Get a user from the store
+
+        NB: there is no reason to call this, it is used by SliXMPP internal API
+
+        :param _gateway_jid:
+        :param _node:
+        :param ifrom:
+        :param iq:
+        :return:
+        """
+        if ifrom is None:  # bug in SliXMPP's XEP_0100 plugin
+            ifrom = iq["from"]
+        log.debug("Getting user %s", ifrom.bare)
+        return self._users.get(ifrom.bare)
+
+    def remove(self, _gateway_jid, _node, ifrom: JID, _iq):
+        """
+        Remove a user from the store
+
+        NB: there is no reason to call this, it is used by SliXMPP internal API
+        """
+        self.remove_by_jid(ifrom)
+
+    def remove_by_jid(self, jid: JID):
+        """
+        Remove a user from the store, by JID
+        """
+        j = jid.bare
+        log.debug("Removing user %s", j)
+        db.user_del(self._users[j])
+        del self._users[j]
+        self._users.sync()
+
+    def get_by_jid(self, jid: JID) -> Optional[GatewayUser]:
+        """
+        Convenience function to get a user from their JID.
+
+        :param jid: JID of the gateway user
+        :return:
+        """
+        return self._users.get(jid.bare)
+
+    def get_by_stanza(self, s: Union[Presence, Message, Iq]) -> Optional[GatewayUser]:
+        """
+        Convenience function to get a user from a stanza they sent.
+
+        :param s: A stanza sent by the gateway user
+        :return:
+        """
+        return self.get_by_jid(s.get_from())
+
+    def close(self):
+        self._users.sync()
+        self._users.close()
+
+
+user_store = UserStore()
+"""
+A persistent store for slidge users. Not public, but I didn't find how to hide
+it from the docs!
+"""
+
+log = logging.getLogger(__name__)