This commit was manufactured by cvs2svn to create branch

'Release_2_1-maint'.

1 files changed, 579 insertions, 0 deletions

diff --git a/Mailman/ListAdmin.py b/Mailman/ListAdmin.py
new file mode 100644
index 00000000..82eedc80
--- /dev/null
+++ b/Mailman/ListAdmin.py
@@ -0,0 +1,579 @@
+# Copyright (C) 1998,1999,2000,2001,2002 by the Free Software Foundation, Inc.
+#
+# 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 2
+# 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, write to the Free Software 
+# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+
+"""Mixin class for MailList which handles administrative requests.
+
+Two types of admin requests are currently supported: adding members to a
+closed or semi-closed list, and moderated posts.
+
+Pending subscriptions which are requiring a user's confirmation are handled
+elsewhere.
+"""
+
+import os
+import time
+import marshal
+import errno
+import cPickle
+from cStringIO import StringIO
+
+import email
+from email.MIMEMessage import MIMEMessage
+from email.Generator import Generator
+from email.Utils import getaddresses
+
+from Mailman import mm_cfg
+from Mailman import Utils
+from Mailman import Message
+from Mailman import Errors
+from Mailman.UserDesc import UserDesc
+from Mailman.Queue.sbcache import get_switchboard
+from Mailman.Logging.Syslog import syslog
+from Mailman import i18n
+
+_ = i18n._
+
+# Request types requiring admin approval
+IGN = 0
+HELDMSG = 1
+SUBSCRIPTION = 2
+UNSUBSCRIPTION = 3
+
+# Return status from __handlepost()
+DEFER = 0
+REMOVE = 1
+LOST = 2
+
+DASH = '-'
+NL = '\n'
+
+
+
+class ListAdmin:
+    def InitVars(self):
+        # non-configurable data
+        self.next_request_id = 1
+
+    def InitTempVars(self):
+        self.__db = None
+
+    def __filename(self):
+        return os.path.join(self.fullpath(), 'request.db')
+
+    def __opendb(self):
+        filename = self.__filename()
+        if self.__db is None:
+            assert self.Locked()
+            try:
+                fp = open(filename)
+                self.__db = marshal.load(fp)
+                fp.close()
+            except IOError, e:
+                if e.errno <> errno.ENOENT: raise
+                self.__db = {}
+            except EOFError, e:
+                # The unmarshalling failed, which means the file is corrupt.
+                # Sigh. Start over.
+                syslog('error',
+                       'request.db file corrupt for list %s, blowing it away.',
+                       self.internal_name())
+                self.__db = {}
+            # Migrate pre-2.1a3 held subscription records to include the
+            # fullname data field.
+            type, version = self.__db.get('version', (IGN, None))
+            if version is None:
+                # No previous revisiont number, must be upgrading to 2.1a3 or
+                # beyond from some unknown earlier version.
+                for id, (type, data) in self.__db.items():
+                    if id == IGN:
+                        pass
+                    elif id == HELDMSG and len(data) == 5:
+                        # tack on a msgdata dictionary
+                        self.__db[id] = data + ({},)
+                    elif id == SUBSCRIPTION and len(data) == 5:
+                        # a fullname field was added
+                        stime, addr, password, digest, lang = data
+                        self.__db[id] = stime, addr, '', password, digest, lang
+                        
+
+    def __closedb(self):
+        if self.__db is not None:
+            assert self.Locked()
+            # Save the version number
+            self.__db['version'] = IGN, mm_cfg.REQUESTS_FILE_SCHEMA_VERSION
+            # Now save a temp file and do the tmpfile->real file dance.  BAW:
+            # should we be as paranoid as for the config.pck file?  Should we
+            # use pickle?
+            tmpfile = self.__filename() + '.tmp'
+            omask = os.umask(002)
+            try:
+                fp = open(tmpfile, 'w')
+                marshal.dump(self.__db, fp)
+                fp.close()
+                self.__db = None
+            finally:
+                os.umask(omask)
+            # Do the dance
+            os.rename(tmpfile, self.__filename())
+
+    def __request_id(self):
+	id = self.next_request_id
+	self.next_request_id += 1
+	return id
+
+    def SaveRequestsDb(self):
+        self.__closedb()
+
+    def NumRequestsPending(self):
+        self.__opendb()
+        # Subtrace one for the version pseudo-entry
+        if self.__db.has_key('version'):
+            return len(self.__db) - 1
+        return len(self.__db)
+
+    def __getmsgids(self, rtype):
+        self.__opendb()
+        ids = [k for k, (type, data) in self.__db.items() if type == rtype]
+        ids.sort()
+        return ids
+
+    def GetHeldMessageIds(self):
+        return self.__getmsgids(HELDMSG)
+
+    def GetSubscriptionIds(self):
+        return self.__getmsgids(SUBSCRIPTION)
+
+    def GetUnsubscriptionIds(self):
+        return self.__getmsgids(UNSUBSCRIPTION)
+
+    def GetRecord(self, id):
+        self.__opendb()
+        type, data = self.__db[id]
+        return data
+
+    def GetRecordType(self, id):
+        self.__opendb()
+        type, data = self.__db[id]
+        return type
+
+    def HandleRequest(self, id, value, comment=None, preserve=None,
+                      forward=None, addr=None):
+        self.__opendb()
+        rtype, data = self.__db[id]
+        if rtype == HELDMSG:
+            status = self.__handlepost(data, value, comment, preserve,
+                                       forward, addr)
+        elif rtype == UNSUBSCRIPTION:
+            status = self.__handleunsubscription(data, value, comment)
+        else:
+            assert rtype == SUBSCRIPTION
+            status = self.__handlesubscription(data, value, comment)
+        if status <> DEFER:
+            # BAW: Held message ids are linked to Pending cookies, allowing
+            # the user to cancel their post before the moderator has approved
+            # it.  We should probably remove the cookie associated with this
+            # id, but we have no way currently of correlating them. :(
+            del self.__db[id]
+
+    def HoldMessage(self, msg, reason, msgdata={}):
+        # Make a copy of msgdata so that subsequent changes won't corrupt the
+        # request database.  TBD: remove the `filebase' key since this will
+        # not be relevant when the message is resurrected.
+        newmsgdata = {}
+        newmsgdata.update(msgdata)
+        msgdata = newmsgdata
+        # assure that the database is open for writing
+        self.__opendb()
+        # get the next unique id
+        id = self.__request_id()
+        assert not self.__db.has_key(id)
+        # get the message sender
+        sender = msg.get_sender()
+        # calculate the file name for the message text and write it to disk
+        if mm_cfg.HOLD_MESSAGES_AS_PICKLES:
+            ext = 'pck'
+        else:
+            ext = 'txt'
+        filename = 'heldmsg-%s-%d.%s' % (self.internal_name(), id, ext)
+        omask = os.umask(002)
+        fp = None
+        try:
+            fp = open(os.path.join(mm_cfg.DATA_DIR, filename), 'w')
+            if mm_cfg.HOLD_MESSAGES_AS_PICKLES:
+                cPickle.dump(msg, fp, 1)
+            else:
+                g = Generator(fp)
+                g(msg, 1)
+        finally:
+            if fp:
+                fp.close()
+            os.umask(omask)
+        # save the information to the request database.  for held message
+        # entries, each record in the database will be of the following
+        # format:
+        #
+        # the time the message was received
+        # the sender of the message
+        # the message's subject
+        # a string description of the problem
+        # name of the file in $PREFIX/data containing the msg text
+        # an additional dictionary of message metadata
+        #
+        msgsubject = msg.get('subject', _('(no subject)'))
+        data = time.time(), sender, msgsubject, reason, filename, msgdata
+        self.__db[id] = (HELDMSG, data)
+        return id
+
+    def __handlepost(self, record, value, comment, preserve, forward, addr):
+        # For backwards compatibility with pre 2.0beta3
+        ptime, sender, subject, reason, filename, msgdata = record
+        path = os.path.join(mm_cfg.DATA_DIR, filename)
+        # Handle message preservation
+        if preserve:
+            parts = os.path.split(path)[1].split(DASH)
+            parts[0] = 'spam'
+            spamfile = DASH.join(parts)
+            # Preserve the message as plain text, not as a pickle
+            try:
+                fp = open(path)
+            except IOError, e:
+                if e.errno <> errno.ENOENT: raise
+                return LOST
+            try:
+                msg = cPickle.load(fp)
+            finally:
+                fp.close()
+            # Save the plain text to a .msg file, not a .pck file
+            outpath = os.path.join(mm_cfg.SPAM_DIR, spamfile)
+            head, ext = os.path.splitext(outpath)
+            outpath = head + '.msg'
+            outfp = open(outpath, 'w')
+            try:
+                g = Generator(outfp)
+                g(msg, 1)
+            finally:
+                outfp.close()
+        # Now handle updates to the database
+        rejection = None
+        fp = None
+        msg = None
+        status = REMOVE
+        if value == mm_cfg.DEFER:
+            # Defer
+            status = DEFER
+        elif value == mm_cfg.APPROVE:
+            # Approved.
+            try:
+                msg = readMessage(path)
+            except IOError, e:
+                if e.errno <> errno.ENOENT: raise
+                return LOST
+            msg = readMessage(path)
+            msgdata['approved'] = 1
+            # adminapproved is used by the Emergency handler
+            msgdata['adminapproved'] = 1
+            # Calculate a new filebase for the approved message, otherwise
+            # delivery errors will cause duplicates.
+            try:
+                del msgdata['filebase']
+            except KeyError:
+                pass
+            # Queue the file for delivery by qrunner.  Trying to deliver the
+            # message directly here can lead to a huge delay in web
+            # turnaround.  Log the moderation and add a header.
+            msg['X-Mailman-Approved-At'] = email.Utils.formatdate(localtime=1)
+            syslog('vette', 'held message approved, message-id: %s',
+                   msg.get('message-id', 'n/a'))
+            # Stick the message back in the incoming queue for further
+            # processing.
+            inq = get_switchboard(mm_cfg.INQUEUE_DIR)
+            inq.enqueue(msg, _metadata=msgdata)
+        elif value == mm_cfg.REJECT:
+            # Rejected
+            rejection = 'Refused'
+            self.__refuse(_('Posting of your message titled "%(subject)s"'),
+                          sender, comment or _('[No reason given]'),
+                          lang=self.getMemberLanguage(sender))
+        else:
+            assert value == mm_cfg.DISCARD
+            # Discarded
+            rejection = 'Discarded'
+        # Forward the message
+        if forward and addr:
+            # If we've approved the message, we need to be sure to craft a
+            # completely unique second message for the forwarding operation,
+            # since we don't want to share any state or information with the
+            # normal delivery.
+            try:
+                copy = readMessage(path)
+            except IOError, e:
+                if e.errno <> errno.ENOENT: raise
+                raise Errors.LostHeldMessage(path)
+            # It's possible the addr is a comma separated list of addresses.
+            addrs = getaddresses([addr])
+            if len(addrs) == 1:
+                realname, addr = addrs[0]
+                # If the address getting the forwarded message is a member of
+                # the list, we want the headers of the outer message to be
+                # encoded in their language.  Otherwise it'll be the preferred
+                # language of the mailing list.
+                lang = self.getMemberLanguage(addr)
+            else:
+                # Throw away the realnames
+                addr = [a for realname, a in addrs]
+                # Which member language do we attempt to use?  We could use
+                # the first match or the first address, but in the face of
+                # ambiguity, let's just use the list's preferred language
+                lang = self.preferred_language
+            otrans = i18n.get_translation()
+            i18n.set_language(lang)
+            try:
+                fmsg = Message.UserNotification(
+                    addr, self.GetBouncesEmail(),
+                    _('Forward of moderated message'),
+                    lang=lang)
+            finally:
+                i18n.set_translation(otrans)
+            fmsg.set_type('message/rfc822')
+            fmsg.attach(copy)
+            fmsg.send(self)
+        # Log the rejection
+	if rejection:
+            note = '''%(listname)s: %(rejection)s posting:
+\tFrom: %(sender)s
+\tSubject: %(subject)s''' % {
+                'listname' : self.internal_name(),
+                'rejection': rejection,
+                'sender'   : sender.replace('%', '%%'),
+                'subject'  : subject.replace('%', '%%'),
+                }
+            if comment:
+                note += '\n\tReason: ' + comment.replace('%', '%%')
+            syslog('vette', note)
+        # Always unlink the file containing the message text.  It's not
+        # necessary anymore, regardless of the disposition of the message.
+        if status <> DEFER:
+            try:
+                os.unlink(path)
+            except OSError, e:
+                if e.errno <> errno.ENOENT: raise
+                # We lost the message text file.  Clean up our housekeeping
+                # and inform of this status.
+                return LOST
+        return status
+            
+    def HoldSubscription(self, addr, fullname, password, digest, lang):
+        # Assure that the database is open for writing
+        self.__opendb()
+        # Get the next unique id
+        id = self.__request_id()
+        assert not self.__db.has_key(id)
+        #
+        # Save the information to the request database. for held subscription
+        # entries, each record in the database will be one of the following
+        # format:
+        #
+        # the time the subscription request was received
+        # the subscriber's address
+        # the subscriber's selected password (TBD: is this safe???)
+        # the digest flag
+	# the user's preferred language
+        #
+        data = time.time(), addr, fullname, password, digest, lang
+        self.__db[id] = (SUBSCRIPTION, data)
+        #
+        # TBD: this really shouldn't go here but I'm not sure where else is
+        # appropriate.
+        syslog('vette', '%s: held subscription request from %s',
+               self.internal_name(), addr)
+        # Possibly notify the administrator in default list language
+        if self.admin_immed_notify:
+            realname = self.real_name
+            subject = _(
+                'New subscription request to list %(realname)s from %(addr)s')
+            text = Utils.maketext(
+                'subauth.txt',
+                {'username'   : addr,
+                 'listname'   : self.internal_name(),
+                 'hostname'   : self.host_name,
+                 'admindb_url': self.GetScriptURL('admindb', absolute=1),
+                 }, mlist=self)
+            # This message should appear to come from the <list>-owner so as
+            # to avoid any useless bounce processing.
+            owneraddr = self.GetOwnerEmail()
+            msg = Message.UserNotification(owneraddr, owneraddr, subject, text,
+                                           self.preferred_language)
+            msg.send(self, **{'tomoderators': 1})
+
+    def __handlesubscription(self, record, value, comment):
+        stime, addr, fullname, password, digest, lang = record
+        if value == mm_cfg.DEFER:
+            return DEFER
+        elif value == mm_cfg.DISCARD:
+            pass
+        elif value == mm_cfg.REJECT:
+            self.__refuse(_('Subscription request'), addr,
+                          comment or _('[No reason given]'),
+                          lang=lang)
+        else:
+            # subscribe
+            assert value == mm_cfg.SUBSCRIBE
+            try:
+                userdesc = UserDesc(addr, fullname, password, digest, lang)
+                self.ApprovedAddMember(userdesc)
+            except Errors.MMAlreadyAMember:
+                # User has already been subscribed, after sending the request
+                pass
+            # TBD: disgusting hack: ApprovedAddMember() can end up closing
+            # the request database.
+            self.__opendb()
+        return REMOVE
+
+    def HoldUnsubscription(self, addr):
+        # Assure the database is open for writing
+        self.__opendb()
+        # Get the next unique id
+        id = self.__request_id()
+        assert not self.__db.has_key(id)
+        # All we need to do is save the unsubscribing address
+        self.__db[id] = (UNSUBSCRIPTION, addr)
+        syslog('vette', '%s: held unsubscription request from %s',
+               self.internal_name(), addr)
+        # Possibly notify the administrator of the hold
+        if self.admin_immed_notify:
+            realname = self.real_name
+            subject = _(
+                'New unsubscription request from %(realname)s by %(addr)s')
+            text = Utils.maketext(
+                'unsubauth.txt',
+                {'username'   : addr,
+                 'listname'   : self.internal_name(),
+                 'hostname'   : self.host_name,
+                 'admindb_url': self.GetScriptURL('admindb', absolute=1),
+                 }, mlist=self)
+            # This message should appear to come from the <list>-owner so as
+            # to avoid any useless bounce processing.
+            owneraddr = self.GetOwnerEmail()
+            msg = Message.UserNotification(owneraddr, owneraddr, subject, text,
+                                           self.preferred_language)
+            msg.send(self, **{'tomoderators': 1})
+
+    def __handleunsubscription(self, record, value, comment):
+        addr = record
+        if value == mm_cfg.DEFER:
+            return DEFER
+        elif value == mm_cfg.DISCARD:
+            pass
+        elif value == mm_cfg.REJECT:
+            self.__refuse(_('Unsubscription request'), addr, comment)
+        else:
+            assert value == mm_cfg.UNSUBSCRIBE
+            try:
+                self.ApprovedDeleteMember(addr)
+            except Errors.NotAMemberError:
+                # User has already been unsubscribed
+                pass
+        return REMOVE
+
+    def __refuse(self, request, recip, comment, origmsg=None, lang=None):
+        # As this message is going to the requestor, try to set the language
+        # to his/her language choice, if they are a member.  Otherwise use the
+        # list's preferred language.
+        realname = self.real_name
+	if lang is None:
+            lang = self.getMemberLanguage(recip)
+        text = Utils.maketext(
+            'refuse.txt',
+            {'listname' : realname,
+             'request'  : request,
+             'reason'   : comment,
+             'adminaddr': self.GetOwnerEmail(),
+            }, lang=lang, mlist=self)
+        otrans = i18n.get_translation()
+        i18n.set_language(lang)
+        try:
+            # add in original message, but not wrap/filled
+            if origmsg:
+                text = NL.join(
+                    [text,
+                     '---------- ' + _('Original Message') + ' ----------',
+                     str(origmsg)
+                     ])
+            subject = _('Request to mailing list %(realname)s rejected')
+        finally:
+            i18n.set_translation(otrans)
+        msg = Message.UserNotification(recip, self.GetBouncesEmail(),
+                                       subject, text, lang)
+        msg.send(self)
+
+    def _UpdateRecords(self):
+        # Subscription records have changed since MM2.0.x.  In that family,
+        # the records were of length 4, containing the request time, the
+        # address, the password, and the digest flag.  In MM2.1a2, they grew
+        # an additional language parameter at the end.  In MM2.1a4, they grew
+        # a fullname slot after the address.  This semi-public method is used
+        # by the update script to coerce all subscription records to the
+        # latest MM2.1 format.
+        #
+        # Held message records have historically either 5 or 6 items too.
+        # These always include the requests time, the sender, subject, default
+        # rejection reason, and message text.  When of length 6, it also
+        # includes the message metadata dictionary on the end of the tuple.
+        self.__opendb()
+        for id, (type, info) in self.__db.items():
+            if type == SUBSCRIPTION:
+                if len(info) == 4:
+                    # pre-2.1a2 compatibility
+                    when, addr, passwd, digest = info
+                    fullname = ''
+                    lang = self.preferred_language
+                elif len(info) == 5:
+                    # pre-2.1a4 compatibility
+                    when, addr, passwd, digest, lang = info
+                    fullname = ''
+                else:
+                    assert len(info) == 6, 'Unknown subscription record layout'
+                    continue
+                # Here's the new layout
+                self.__db[id] = when, addr, fullname, passwd, digest, lang
+            elif type == HELDMSG:
+                if len(info) == 5:
+                    when, sender, subject, reason, text = info
+                    msgdata = {}
+                else:
+                    assert len(info) == 6, 'Unknown held msg record layout'
+                    continue
+                # Here's the new layout
+                self.__db[id] = when, sender, subject, reason, text, msgdata
+        # All done
+        self.__closedb()
+
+
+
+def readMessage(path):
+    # For backwards compatibility, we must be able to read either a flat text
+    # file or a pickle.
+    ext = os.path.splitext(path)[1]
+    fp = open(path)
+    try:
+        if ext == '.txt':
+            msg = email.message_from_file(fp, Message.Message)
+        else:
+            assert ext == '.pck'
+            msg = cPickle.load(fp)
+    finally:
+        fp.close()
+    return msg