Kolab Groupware OBS

pykolab.spec Changed

0001-Fix-resolving-referrals.patch Deleted

debian.changelog Changed

debian.series Changed

pykolab-0.8.13.tar.gz/.flake8 Added

pykolab-0.8.13.tar.gz/.pylintrc Added

pykolab-0.8.12.tar.gz/conf/kolab.conf -> pykolab-0.8.13.tar.gz/conf/kolab.conf Changed

@@ -428,9 +428,51 @@
 result_attribute = mail
 
 [wallace]
-modules = resources, invitationpolicy, footer
-footer_text = /etc/kolab/footer.text
-footer_html = /etc/kolab/footer.html
+; List the modules to load and apply, in order.
+;
+; Available modules include;
+;
+; * resources
+; * invitationpolicy
+; * footer
+; * signature
+;
+modules = resources, invitationpolicy
+
+; Footer module settings
+;footer_text = /etc/kolab/footer.text
+;footer_html = /etc/kolab/footer.html
+
+; Signature module settings
+;
+; Two modes: write out the exact signature in /etc/kolab/ as html and/or text,
+; or use rules.
+;
+; If files are configured, rules do not apply. If files are configured, a
+; fallback is /etc/kolab/signature_default.{html,txt}.
+;
+; signature_file_html = /etc/kolab/signature.d/%(mail)s.html
+; signature_file_text = /etc/kolab/signature.d/%(mail)s.txt
+;
+; A list of dicts, with each dict holding an attribute name ("o", "cn",
+; "entrydn"), and a regular expression to be matched against the attribute
+; value.
+;
+; The module takes the first match, and uses the "html" and "text" files as
+; templates.
+;
+;signature_rules = [
+;        {
+;                "entrydn": "uid=.*,ou=IT,ou=People,dc=example,dc=org",
+;                "html": "/etc/kolab/signature_IT.html",
+;                "text": "/etc/kolab/signature_IT.txt"
+;            },
+;        {
+;                "entrydn": "uid=.*,ou=Finance,ou=People,dc=example,dc=org",
+;                "html": "/etc/kolab/signature_Finance.html",
+;                "text": "/etc/kolab/signature_Finance.txt"
+;            }
+;    ]
 
 ; default settings for kolabInvitationPolicy LDAP attribute on user records
 kolab_invitation_policy = ACT_ACCEPT_IF_NO_CONFLICT:example.org, ACT_MANUAL

pykolab-0.8.13.tar.gz/conf/signature_IT.html Added

pykolab-0.8.13.tar.gz/conf/signature_IT.txt Added

pykolab-0.8.12.tar.gz/configure.ac -> pykolab-0.8.13.tar.gz/configure.ac Changed

pykolab-0.8.12.tar.gz/pykolab/auth/ldap/__init__.py -> pykolab-0.8.13.tar.gz/pykolab/auth/ldap/__init__.py Changed

pykolab-0.8.12.tar.gz/pykolab/setup/setup_ldap.py -> pykolab-0.8.13.tar.gz/pykolab/setup/setup_ldap.py Changed

pykolab-0.8.12.tar.gz/pykolab/setup/setup_roundcube.py -> pykolab-0.8.13.tar.gz/pykolab/setup/setup_roundcube.py Changed

pykolab-0.8.12.tar.gz/wallace/__init__.py -> pykolab-0.8.13.tar.gz/wallace/__init__.py Changed

@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
-# Copyright 2010-2013 Kolab Systems AG (http://www.kolabsys.com)
+# Copyright 2010-2019 Kolab Systems AG (http://www.kolabsys.com)
 #
 # Jeroen van Meeuwen (Kolab Systems) <vanmeeuwen a kolabsys.com>
 #
@@ -17,6 +17,8 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 
+from __future__ import print_function
+
 import asyncore
 from distutils import version
 import grp
@@ -31,31 +33,33 @@
 import tempfile
 from threading import _Timer
 import time
-import traceback
 
 import pykolab
 from pykolab import utils
 from pykolab.translate import _
 
+from modules import cb_action_ACCEPT
+
+# pylint: disable=invalid-name
 log = pykolab.getLogger('pykolab.wallace')
 conf = pykolab.getConf()
 
-from modules import cb_action_ACCEPT
 
-def pickup_message(filepath, *args, **kw):
+def pickup_message(filepath, *args, **kwargs):
     wallace_modules = args[0]
-    if kw.has_key('module'):
+
+    if 'module' in kwargs:
 
         # Cause the previous modules to be skipped
-        wallace_modules = wallace_modules[(wallace_modules.index(kw['module'])+1):]
+        wallace_modules = wallace_modules[(wallace_modules.index(kwargs['module']) + 1):]
 
         log.debug(_("Wallace modules: %r") % (wallace_modules), level=8)
 
         # Execute the module
-        if kw.has_key('stage'):
-            modules.execute(kw['module'], filepath, stage=kw['stage'])
+        if 'stage' in kwargs:
+            modules.execute(kwargs['module'], filepath, stage=kwargs['stage'])
         else:
-            modules.execute(kw['module'], filepath)
+            modules.execute(kwargs['module'], filepath)
 
     # After all modules are executed, continue with a call to
     # accept the message and re-inject in to Postfix.
@@ -64,11 +68,18 @@
     for module in wallace_modules:
         try:
             result_filepath = modules.execute(module, filepath)
-        except:
-            log.error(_("Module %s.execute() failed on message %r with error: %s" % (module, filepath, traceback.format_exc())))
+        except Exception:
+            log.error(
+                "Module %s.execute() failed on message %r with error: %s" % (
+                    module,
+                    filepath,
+                    traceback.format_exc()
+                )
+            )
+
             result_filepath = False
 
-        if not result_filepath == None and not result_filepath == False:
+        if result_filepath is not None and result_filepath is not False:
             filepath = result_filepath
         else:
             # A module has returned False or None
@@ -80,26 +91,38 @@
     if continue_with_accept:
         cb_action_ACCEPT('wallace', filepath)
 
+
 def modules_heartbeat(wallace_modules):
     lastrun = 0
 
-    while True:
+    while not multiprocessing.current_process().finished.is_set():
         try:
             for module in wallace_modules:
                 try:
                     modules.heartbeat(module, lastrun)
-                except:
-                    log.error(_("Module %s.heartbeat() failed with error: %s" % (module, traceback.format_exc())))
+                except Exception:
+                    log.error(
+                        "Module %s.heartbeat() failed with error: %s" % (
+                            module,
+                            traceback.format_exc()
+                        )
+                    )
 
             lastrun = int(time.time())
-            time.sleep(60)
-        except (SystemExit, KeyboardInterrupt), e:
-            log.info("Terminating heartbeat process")
+            multiprocessing.current_process().finished.wait(60)
+
+        except (SystemExit, KeyboardInterrupt) as errmsg:
+            log.warning("Exiting %s, %s" % (multiprocessing.current_process().name, errmsg))
             break
 
-def worker_process(*args, **kw):
-    log.debug(_("Worker process %s initializing") % (multiprocessing.current_process().name), level=1)
 
+def worker_process(*args, **kwargs):
+    import signal
+    signal.signal(signal.SIGINT, signal.SIG_IGN)
+    log.debug("Worker process %s initializing" % (multiprocessing.current_process().name), level=1)
+
+
+# pylint: disable=too-few-public-methods
 class Timer(_Timer):
     def run(self):
         while True:
@@ -109,92 +132,99 @@
 
             self.finished.set()
 
-class WallaceDaemon(object):
+
+class WallaceDaemon:
     def __init__(self):
         self.current_connections = 0
         self.max_connections = 24
+        self.parent_pid = None
         self.pool = None
 
         daemon_group = conf.add_cli_parser_option_group(_("Daemon Options"))
 
         daemon_group.add_option(
-                "--fork",
-                dest    = "fork_mode",
-                action  = "store_true",
-                default = False,
-                help    = _("Fork to the background.")
-            )
+            "--fork",
+            dest="fork_mode",
+            action="store_true",
+            default=False,
+            help=_("Fork to the background.")
+        )
 
         daemon_group.add_option(
-                "-b", "--bind",
-                dest    = "wallace_bind_address",
-                action  = "store",
-                default = "localhost",
-                help    = _("Bind address for Wallace.")
-            )
+            "-b", "--bind",
+            dest="wallace_bind_address",
+            action="store",
+            default="localhost",
+            help=_("Bind address for Wallace.")
+        )
 
         daemon_group.add_option(
-                "-g",
-                "--group",
-                dest    = "process_groupname",
-                action  = "store",
-                default = "kolab",
-                help    = _("Run as group GROUPNAME"),
-                metavar = "GROUPNAME"
-            )
+            "-g", "--group",
+            dest="process_groupname",
+            action="store",
+            default="kolab",
+            help=_("Run as group GROUPNAME"),
+            metavar="GROUPNAME"
+        )
 
         daemon_group.add_option(
-                "--threads",
-                dest    = "max_threads",
-                action  = "store",
-                default = 4,
-                type    = int,
-                help    = _("Number of threads to use.")
-            )
+            "--threads",
+            dest="max_threads",
+            action="store",
+            default=4,
+            type=int,

pykolab-0.8.13.tar.gz/wallace/module_signature.py Added

@@ -0,0 +1,248 @@
+# -*- coding: utf-8 -*-
+# Copyright 2010-2019 Kolab Systems AG (http://www.kolabsys.com)
+#
+# Jeroen van Meeuwen (Kolab Systems) <vanmeeuwen a kolabsys.com>
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU 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 General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+import json
+import os
+import re
+import tempfile
+
+from email.encoders import encode_quopri
+from email.parser import Parser
+from email.utils import getaddresses
+
+import modules
+import pykolab
+
+from pykolab.auth import Auth
+from pykolab.translate import _
+
+# pylint: disable=invalid-name
+log = pykolab.getLogger('pykolab.wallace')
+conf = pykolab.getConf()
+
+mybasepath = '/var/spool/pykolab/wallace/signature/'
+
+
+def __init__():
+    modules.register('signature', execute, description=description())
+
+
+def description():
+    return """Append a signature to messages."""
+
+
+def set_part_content(part, content):
+    # Reset old encoding and use quoted-printable (#5414)
+    del part['Content-Transfer-Encoding']
+    part.set_payload(content)
+    encode_quopri(part)
+
+    return True
+
+
+def attr_resolve(sender_info, attr):
+    try:
+        attr, attr_val = attr.split(':')
+    except ValueError:
+        return None
+
+    auth = Auth()
+    auth.connect()
+
+    values = []
+
+    if not isinstance(sender_info[attr], list):
+        sender_info[attr] = [sender_info[attr]]
+
+    for sender_attr_val in sender_info[attr]:
+        values.append(auth.get_entry_attribute(None, sender_attr_val, attr_val))
+
+    return ", ".join(values)
+
+
+# pylint: disable=too-many-branches,too-many-locals,too-many-statements
+def execute(*args, **kw):  # noqa: C901
+    if not os.path.isdir(mybasepath):
+        os.makedirs(mybasepath)
+
+    for stage in ['incoming', 'ACCEPT']:
+        if not os.path.isdir(os.path.join(mybasepath, stage)):
+            os.makedirs(os.path.join(mybasepath, stage))
+
+    # TODO: Test for correct call.
+    filepath = args[0]
+
+    if 'stage' in kw:
+        log.debug(_("Issuing callback after processing to stage %s") % (kw['stage']), level=8)
+        log.debug(_("Testing cb_action_%s()") % (kw['stage']), level=8)
+        if hasattr(modules, 'cb_action_%s' % (kw['stage'])):
+            log.debug(_("Attempting to execute cb_action_%s()") % (kw['stage']), level=8)
+            exec('modules.cb_action_%s(%r, %r)' % (kw['stage'], 'signature', filepath))
+            return
+
+    log.debug(_("Executing module signature for %r, %r") % (args, kw), level=8)
+
+    new_filepath = os.path.join(
+        '/var/spool/pykolab/wallace/signature/incoming',
+        os.path.basename(filepath)
+    )
+
+    os.rename(filepath, new_filepath)
+    filepath = new_filepath
+
+    # parse message
+    message = Parser().parse(open(filepath, 'r'))
+
+    sender_address = [
+        address for displayname, address in getaddresses(message.get_all('X-Kolab-From'))
+    ][0]
+
+    auth = Auth()
+    auth.connect()
+
+    sender_dn = auth.find_recipient(sender_address)
+    if not sender_dn:
+        exec('modules.cb_action_%s(%r, %r)' % ('ACCEPT', 'signature', filepath))
+        return
+
+    sender_info = auth.get_entry_attributes(None, sender_dn, ['*', 'entrydn', 'manager'])
+
+    log.debug("Sender info: %r" % (sender_info), level=7)
+
+    signature_rules = conf.get_raw('wallace', 'signature_rules')
+
+    if signature_rules:
+        signature_rules = json.loads(signature_rules)
+
+    log.debug("Signature rules: %r" % (signature_rules), level=7)
+
+    signature_html = None
+    signature_text = None
+
+    sig_html_conf = conf.get_raw('wallace', 'signature_file_html')
+    sig_text_conf = conf.get_raw('wallace', 'signature_file_text')
+
+    if sig_html_conf and sig_text_conf:
+        _sig_html_conf = sig_html_conf % sender_info
+        _sig_text_conf = sig_text_conf % sender_info
+
+        if not os.path.exists(_sig_html_conf):
+            _sig_html_conf = '/etc/kolab/signature.d/default.html'
+
+        if not os.path.exists(_sig_text_conf):
+            _sig_text_conf = '/etc/kolab/signature.d/default.txt'
+
+        if os.path.exists(_sig_html_conf):
+            signature_html = open(_sig_html_conf, 'r').read()
+
+        if os.path.exists(_sig_text_conf):
+            signature_text = open(_sig_text_conf, 'r').read()
+
+    if not signature_html and not signature_text:
+        for signature_rule in signature_rules:
+            try:
+                for attr, regex in signature_rule.iteritems():
+                    if attr == "html":
+                        if not os.path.exists(signature_rule['html']):
+                            raise ValueError
+                        continue
+
+                    if attr == "text":
+                        if not os.path.exists(signature_rule['text']):
+                            raise ValueError
+                        continue
+
+                    if attr in sender_info and re.match(regex, sender_info[attr], flags=re.IGNORECASE):
+                        success = False
+
+                        while not success:
+                            try:
+                                signature_html = open(signature_rule['html'], 'r').read() % sender_info
+                                signature_text = open(signature_rule['text'], 'r').read() % sender_info
+
+                                success = True
+
+                            except KeyError as errmsg:
+                                sender_info[errmsg] = attr_resolve(sender_info, errmsg)
+            except ValueError:
+                continue
+
+    if signature_html is None and signature_text is None:
+        exec('modules.cb_action_%s(%r, %r)' % ('ACCEPT', 'signature', filepath))
+        return
+
+    signature_added = False
+
+    try:
+        _signature_added = message.get("X-Wallace-Signature")
+
+    # pylint: disable=broad-except
+    except Exception:
+        pass
+
+    if _signature_added == "YES":

pykolab-0.8.12.tar.gz/wallace/modules.py -> pykolab-0.8.13.tar.gz/wallace/modules.py Changed

@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
-# Copyright 2010-2013 Kolab Systems AG (http://www.kolabsys.com)
+# Copyright 2010-2019 Kolab Systems AG (http://www.kolabsys.com)
 #
 # Jeroen van Meeuwen (Kolab Systems) <vanmeeuwen a kolabsys.com>
 #
@@ -17,6 +17,8 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 
+from __future__ import print_function
+
 import os
 import sys
 import time
@@ -45,6 +47,7 @@
 
 modules = {}
 
+
 def __init__():
     # We only want the base path
     modules_base_path = os.path.dirname(__file__)
@@ -55,15 +58,16 @@
 
         for filename in filenames:
             if filename.startswith('module_') and filename.endswith('.py'):
-                module_name = filename.replace('.py','')
+                module_name = filename.replace('.py', '')
                 name = module_name.replace('module_', '')
-                #print "exec(\"from %s import __init__ as %s_register\"" % (module_name,name)
+                # print("exec(\"from %s import __init__ as %s_register\")" % (module_name,name))
                 exec("from %s import __init__ as %s_register" % (module_name, name))
                 exec("%s_register()" % (name))
 
         for dirname in dirnames:
             register_group(modules_path, dirname)
 
+
 def list_modules(*args, **kw):
     """
         List modules
@@ -75,8 +79,8 @@
         if isinstance(module, tuple):
             module_group, module = module
             __modules[module_group] = {
-                    module: modules[(module_group,module)]
-                }
+                module: modules[(module_group, module)]
+            }
         else:
             __modules[module] = modules[module]
 
@@ -84,38 +88,45 @@
     _modules.sort()
 
     for _module in _modules:
-        if __modules[_module].has_key('function'):
+        if 'function' in __modules[_module]:
             # This is a top-level module
-            if not __modules[_module]['description'] == None:
-                print "%-25s - %s" % (_module.replace('_','-'),__modules[_module]['description'])
+            if __modules[_module]['description'] is not None:
+                print("%-25s - %s" % (_module.replace('_', '-'), __modules[_module]['description']))
             else:
-                print "%-25s" % (_module.replace('_','-'))
+                print("%-25s" % (_module.replace('_', '-')))
 
     for _module in _modules:
-        if not __modules[_module].has_key('function'):
+        if 'function' not in __modules[_module]:
             # This is a nested module
-            print "\n" + _("Module Group: %s") % (_module) + "\n"
+            print("\n" + _("Module Group: %s") % (_module) + "\n")
             ___modules = __modules[_module].keys()
             ___modules.sort()
             for __module in ___modules:
-                if not __modules[_module][__module]['description'] == None:
-                    print "%-4s%-21s - %s" % ('',__module.replace('_','-'),__modules[_module][__module]['description'])
+                if __modules[_module][__module]['description'] is not None:
+                    print(
+                        "%-4s%-21s - %s" % (
+                            '',
+                            _module.replace('_', '-'),
+                            __modules[_module][__module]['description']
+                        )
+                    )
+
                 else:
-                    print "%-4s%-21s" % ('',__module.replace('_','-'))
+                    print("%-4s%-21s" % ('', __module.replace('_', '-')))
+
 
 def execute(name, *args, **kw):
-    if not modules.has_key(name):
+    if name not in modules:
         log.error(_("No such module %r in modules %r (1).") % (name, modules))
         sys.exit(1)
 
-    if not modules[name].has_key('function') and \
-        not modules[name].has_key('group'):
-        log.error(_("No such module %r in modules %r (2).") %(name, modules))
+    if 'function' not in modules[name] and 'group' not in modules[name]:
+        log.error(_("No such module %r in modules %r (2).") % (name, modules))
         sys.exit(1)
 
     try:
         return modules[name]['function'](*args, **kw)
-    except Exception, errmsg:
+    except Exception as errmsg:
         log.exception(_("Module %r - Unknown error occurred; %r") % (name, errmsg))
 
 def heartbeat(name, *args, **kw):
@@ -156,35 +167,35 @@
             success = True
             break
 
-        except smtplib.SMTPServerDisconnected, errmsg:
+        except smtplib.SMTPServerDisconnected as errmsg:
             log.error("SMTP Server Disconnected Error, %r" % (errmsg))
 
-        except smtplib.SMTPConnectError, errmsg:
+        except smtplib.SMTPConnectError as errmsg:
             # DEFER
             log.error("SMTP Connect Error, %r" % (errmsg))
 
-        except smtplib.SMTPDataError, errmsg:
+        except smtplib.SMTPDataError as errmsg:
             # DEFER
             log.error("SMTP Data Error, %r" % (errmsg))
 
-        except smtplib.SMTPHeloError, errmsg:
+        except smtplib.SMTPHeloError as errmsg:
             # DEFER
             log.error("SMTP HELO Error, %r" % (errmsg))
 
-        except smtplib.SMTPRecipientsRefused, errmsg:
+        except smtplib.SMTPRecipientsRefused as errmsg:
             # REJECT, send NDR
             log.error("SMTP Recipient(s) Refused, %r" % (errmsg))
 
-        except smtplib.SMTPSenderRefused, errmsg:
+        except smtplib.SMTPSenderRefused as errmsg:
             # REJECT, send NDR
             log.error("SMTP Sender Refused, %r" % (errmsg))
 
-        except Exception, errmsg:
+        except Exception as errmsg:
             log.exception(_("smtplib - Unknown error occurred: %r") % (errmsg))
 
         try:
             smtp.quit()
-        except Exception, errmsg:
+        except Exception as errmsg:
             log.error("smtplib quit() error - %r" % errmsg)
 
         time.sleep(10)
@@ -231,7 +242,7 @@
     #now = datetime.datetime.now()
     #delta = now - fileage
 
-    #print "file:", filepath, "fileage:", fileage, "now:", now, "delta(seconds):", delta.seconds
+    #print("file:", filepath, "fileage:", fileage, "now:", now, "delta(seconds):", delta.seconds)
 
     #if delta.seconds > 1800:
         ## TODO: Send NDR back to user

pykolab-0.8.12.tar.gz/wallace/wallace.systemd -> pykolab-0.8.13.tar.gz/wallace/wallace.systemd Changed

pykolab.dsc Changed

Changes of Revision 42