This commit was manufactured by cvs2svn to create branch

'Release_2_1-maint'.

34 files changed, 6992 insertions, 0 deletions

diff --git a/bin/.cvsignore b/bin/.cvsignore
new file mode 100644
index 00000000..7bda5c8c
--- /dev/null
+++ b/bin/.cvsignore
@@ -0,0 +1,2 @@
+.cvsignore
+Makefile
diff --git a/bin/Makefile.in b/bin/Makefile.in
new file mode 100644
index 00000000..a406ca46
--- /dev/null
+++ b/bin/Makefile.in
@@ -0,0 +1,78 @@
+# 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.
+
+# NOTE: Makefile.in is converted into Makefile by the configure script
+# in the parent directory.  Once configure has run, you can recreate
+# the Makefile by running just config.status.
+
+# Variables set by configure
+
+VPATH=		@srcdir@
+srcdir= 	@srcdir@
+bindir= 	@bindir@
+prefix=   	@prefix@
+exec_prefix=	@exec_prefix@
+
+CC=		@CC@
+CHMOD=  	@CHMOD@
+INSTALL=	@INSTALL@
+
+DEFS=   	@DEFS@
+
+# Customizable but not set by configure
+
+OPT=		@OPT@
+CFLAGS=		$(OPT) $(DEFS)
+MAILDIR=	$(exec_prefix)/mail
+SCRIPTSDIR= 	$(prefix)/bin
+
+SHELL=		/bin/sh
+
+SCRIPTS=	mmsitepass newlist rmlist add_members \
+		list_members remove_members clone_member update arch \
+		sync_members check_db withlist check_perms find_member \
+		version config_list list_lists dumpdb cleanarch \
+		list_admins genaliases change_pw mailmanctl qrunner inject \
+		unshunt fix_url.py convert.py transcheck b4b5-archfix \
+		list_owners
+
+BUILDDIR=	../build/bin
+
+# Modes for directories and executables created by the install
+# process.  Default to group-writable directories but
+# user-only-writable for executables.
+DIRMODE=	775
+EXEMODE=	755
+FILEMODE=	644
+INSTALL_PROGRAM=$(INSTALL) -m $(EXEMODE)
+
+
+# Rules
+
+all:
+
+install:
+	for f in $(SCRIPTS); \
+	do \
+	    $(INSTALL) -m $(EXEMODE) $(BUILDDIR)/$$f $(SCRIPTSDIR); \
+	done
+
+finish:
+
+clean:
+
+distclean:
+	-rm Makefile
diff --git a/bin/add_members b/bin/add_members
new file mode 100755
index 00000000..ad4f43b8
--- /dev/null
+++ b/bin/add_members
@@ -0,0 +1,297 @@
+#! @PYTHON@
+#
+# 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.
+#
+# argv[1] should be the name of the list.
+# argv[2] should be the list of non-digested users.
+# argv[3] should be the list of digested users.
+
+# Make sure that the list of email addresses doesn't contain any comments,
+# like majordomo may throw in.  For now, you just have to remove them manually.
+
+"""Add members to a list from the command line.
+
+Usage:
+    add_members [options] listname
+
+Options:
+
+    --regular-members-file=file
+    -r file
+        A file containing addresses of the members to be added, one
+        address per line.  This list of people become non-digest
+        members.  If file is `-', read addresses from stdin.  Note that
+        -n/--non-digest-members-file are deprecated synonyms for this option.
+
+    --digest-members-file=file
+    -d=file
+        Similar to above, but these people become digest members.
+
+    --changes-msg=<y|n>
+    -c <y|n> 
+	Set whether or not to send the list members the `there's going to be
+	big changes to your list' message. defaults to no.
+
+    --welcome-msg=<y|n>
+    -w <y|n>
+        Set whether or not to send the list members a welcome message,
+        overriding whatever the list's `send_welcome_msg' setting is.
+
+    --admin-notify=<y|n>
+    -a <y|n>
+        Set whether or not to send the list administrators a notification on
+        the success/failure of these subscriptions, overriding whatever the
+        list's `admin_notify_mchanges' setting is.
+
+    --help
+    -h
+        Print this help message and exit.
+
+    listname
+        The name of the Mailman list you are adding members to.  It must
+        already exist.
+
+You must supply at least one of -r and -d options.  At most one of the
+files can be `-'.
+"""
+
+import sys
+import os
+import getopt
+from cStringIO import StringIO
+
+import paths
+# Import this /after/ paths so that the sys.path is properly hacked
+from email.Utils import parseaddr
+
+from Mailman import MailList
+from Mailman import Utils
+from Mailman import Message
+from Mailman import Errors
+from Mailman import mm_cfg
+from Mailman import i18n
+
+_ = i18n._
+
+
+
+def usage(status, msg=''):
+    if status:
+        fd = sys.stderr
+    else:
+        fd = sys.stdout
+    print >> fd, _(__doc__)
+    if msg:
+        print >> fd, msg
+    sys.exit(status)
+
+
+
+def readfile(filename):
+    if filename == '-':
+        fp = sys.stdin
+        closep = 0
+    else:
+        fp = open(filename)
+        closep = 1
+    # strip all the lines of whitespace and discard blank lines
+    lines = filter(None, [line.strip() for line in fp.readlines()])
+    if closep:
+        fp.close()
+    return lines
+
+
+
+def SendExplanation(mlist, users):
+    listname = mlist.real_name
+    listhost = mlist.host_name
+    d = {'listname'    : listname,
+         'listhost'    : listhost,
+         'listaddr'    : mlist.GetListEmail(),
+         'listinfo_url': mlist.GetScriptURL('listinfo', absolute=1),
+         'requestaddr' : mlist.GetRequestEmail(),
+         'adminaddr'   : mlist.GetOwnerEmail(),
+         'version'     : mm_cfg.VERSION,
+         }
+    otrans = i18n.get_translation()
+    i18n.set_language(mlist.preferred_language)
+    try:
+        text = Utils.maketext('convert.txt', d)
+        subject = _('Big change in %(listname)s@%(listhost)s mailing list')
+        msg = Message.UserNotification(users, mlist.GetBouncesEmail(),
+                                       subject, text,
+                                       mlist.preferred_language)
+    finally:
+        i18n.set_translation(otrans)
+    msg.send(mlist)
+
+
+
+class Tee:
+    def __init__(self, outfp):
+        self.__outfp = outfp
+
+    def write(self, msg):
+        sys.stdout.write(msg)
+        self.__outfp.write(msg)
+
+
+class UserDesc: pass
+
+
+
+def addall(mlist, members, digest, ack, outfp):
+    tee = Tee(outfp)
+    for member in members:
+        userdesc = UserDesc()
+        userdesc.fullname, userdesc.address = parseaddr(member)
+        userdesc.digest = digest
+
+        try:
+            mlist.ApprovedAddMember(userdesc, ack, 0)
+        except Errors.MMAlreadyAMember:
+            print >> tee, _('Already a member: %(member)s')
+        except Errors.MMBadEmailError:
+            if userdesc.address == '':
+                print >> tee, _('Bad/Invalid email address: blank line')
+            else:
+                print >> tee, _('Bad/Invalid email address: %(member)s')
+        except Errors.MMHostileAddress:
+            print >> tee, _('Hostile address (illegal characters): %(member)s')
+        else:
+            print >> tee, _('Subscribed: %(member)s')
+        
+
+
+def main():
+    try:
+        opts, args = getopt.getopt(sys.argv[1:],
+                                   'a:n:r:d:c:w:h',
+                                   ['admin-notify=',
+                                    'regular-members-file=',
+                                    'non-digest-members-file=',
+                                    'digest-members-file=',
+                                    'changes-msg=',
+				    'welcome-msg=',
+                                    'help'])
+    except getopt.error, msg:
+        usage(1, msg)
+
+    if len(args) <> 1:
+        usage(1)
+
+    listname = args[0].lower().strip()
+    nfile = None
+    dfile = None
+    send_changes_msg = 0
+    send_welcome_msg = None
+    admin_notif = None
+    for opt, arg in opts:
+        if opt in ('-h', '--help'):
+            usage(0)
+        elif opt in ('-d', '--digest-members-file'):
+            dfile = arg
+        # Deprecate -/--non-digest-members-file or consistency with
+        # list_members
+        elif opt in ('-r', '--regular-members-file'):
+            nfile = arg
+        elif opt in ('-n', '--non-digest-members-file'):
+            nfile = arg
+            # I don't think we need to use the warnings module here.
+            print >> sys.stderr, 'option', opt, \
+                  'is deprecated, use -r/--regular-members-file'
+        elif opt in ('-c', '--changes-msg'):
+            if arg.lower()[0] == 'y':
+                send_changes_msg = 1
+            elif arg.lower()[0] == 'n':
+                send_changes_msg = 0
+            else:
+                usage(1, _('Bad argument to -c/--changes-msg: %(arg)s'))
+        elif opt in ('-w', '--welcome-msg'):
+            if arg.lower()[0] == 'y':
+                send_welcome_msg = 1
+            elif arg.lower()[0] == 'n':
+                send_welcome_msg = 0
+            else:
+                usage(1, _('Bad argument to -w/--welcome-msg: %(arg)s'))
+        elif opt in ('-a', '--admin-notify'):
+            if arg.lower()[0] == 'y':
+                admin_notif = 1
+            elif arg.lower()[0] == 'n':
+                admin_notif = 0
+            else:
+                usage(1, _('Bad argument to -a/--admin-notify: %(arg)s'))
+                
+    if dfile is None and nfile is None:
+        usage(1)
+
+    if dfile == "-" and nfile == "-":
+        usage(1, _('Cannot read both digest and normal members '
+                   'from standard input.'))
+
+    try:
+        mlist = MailList.MailList(listname)
+    except Errors.MMUnknownListError:
+        usage(1, _('No such list: %(listname)s'))
+
+    # Set up defaults
+    if send_welcome_msg is None:
+        send_welcome_msg = mlist.send_welcome_msg
+    if admin_notif is None:
+        admin_notif = mlist.admin_notify_mchanges
+
+    otrans = i18n.get_translation()
+    # Read the regular and digest member files
+    try:
+        dmembers = []
+        if dfile:
+            dmembers = readfile(dfile)
+
+        nmembers = []
+        if nfile:
+            nmembers = readfile(nfile)
+
+        if not dmembers and not nmembers:
+            usage(0, _('Nothing to do.'))
+
+        s = StringIO()
+        i18n.set_language(mlist.preferred_language)
+        if nmembers:
+            addall(mlist, nmembers, 0, send_welcome_msg, s)
+
+        if dmembers:
+            addall(mlist, dmembers, 1, send_welcome_msg, s)
+
+        if admin_notif:
+            realname = mlist.real_name
+            subject = _('%(realname)s subscription notification')
+            msg = Message.UserNotification(
+                mlist.owner, Utils.get_site_email(), subject, s.getvalue(),
+                mlist.preferred_language)
+            msg.send(mlist)
+
+        if send_changes_msg:
+            SendExplanation(mlist, nmembers + dmembers)
+
+        mlist.Save()
+    finally:
+        mlist.Unlock()
+        i18n.set_translation(otrans)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/bin/arch b/bin/arch
new file mode 100644
index 00000000..be430f68
--- /dev/null
+++ b/bin/arch
@@ -0,0 +1,187 @@
+#! @PYTHON@
+#
+# 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.
+
+"""Rebuild a list's archive.
+
+Use this command to rebuild the archives for a mailing list.  You may want to
+do this if you edit some messages in an archive, or remove some messages from
+an archive.
+
+Usage: %(PROGRAM)s [options] <listname> [<mbox>]
+
+Where options are:
+    -h / --help
+        Print this help message and exit.
+
+    -q / --quiet
+        Make the archiver output less verbose.
+
+    --wipe
+        First wipe out the original archive before regenerating.  You usually
+        want to specify this argument unless you're generating the archive in
+        chunks.
+
+    -s N
+    --start=N
+        Start indexing at article N, where article 0 is the first in the mbox.
+        Defaults to 0.
+
+    -e M
+    --end=M
+        End indexing at article M.  This script is not very efficient with
+        respect to memory management, and for large archives, it may not be
+        possible to index the mbox entirely.  For that reason, you can specify
+        the start and end article numbers.
+
+Where <mbox> is the path to a list's complete mbox archive.  Usually this will
+be some path in the archives/private directory.  For example:
+
+%% bin/arch mylist archives/private/mylist.mbox/mylist.mbox
+
+<mbox> is optional.  If it is missing, it is calculated.
+"""
+
+import os
+import sys
+import getopt
+import shutil
+
+import paths
+from Mailman import mm_cfg
+from Mailman import Errors
+
+from Mailman.MailList import MailList
+from Mailman.Archiver.HyperArch import HyperArchive
+from Mailman.LockFile import LockFile
+from Mailman import i18n
+
+_ = i18n._
+
+PROGRAM = sys.argv[0]
+i18n.set_language(mm_cfg.DEFAULT_SERVER_LANGUAGE)
+
+
+
+def usage(code, msg=''):
+    if code:
+        fd = sys.stderr
+    else:
+        fd = sys.stdout
+    print >> fd, _(__doc__)
+    if msg:
+        print >> fd, msg
+    sys.exit(code)
+
+
+
+def main():
+    # get command line arguments
+    try:
+        opts, args = getopt.getopt(
+            sys.argv[1:], 'hs:e:q',
+            ['help', 'start', 'end', 'quiet', 'wipe'])
+    except getopt.error, msg:
+        usage(1, msg)
+
+    start = None
+    end = None
+    verbose = 1
+    wipe = 0
+    for opt, arg in opts:
+        if opt in ('-h', '--help'):
+            usage(0)
+        elif opt in ('-s', '--start'):
+            try:
+                start = int(arg)
+            except ValueError:
+                usage(1)
+        elif opt in ('-e', '--end'):
+            try:
+                end = int(arg)
+            except ValueError:
+                usage(1)
+        elif opt in ('-q', '--quiet'):
+            verbose = 0
+        elif opt == '--wipe':
+            wipe = 1
+
+    # grok arguments
+    if len(args) < 1:
+        usage(1, _('listname is required'))
+    listname = args[0].lower().strip()
+
+    if len(args) < 2:
+        mbox = None
+    else:
+        mbox = args[1]
+
+    if len(args) > 2:
+        usage(1)
+
+    # open the mailing list object
+    mlist = None
+    lock = None
+    try:
+        try:
+            mlist = MailList(listname)
+        except Errors.MMListError, e:
+            usage(2, _('No such list "%(listname)s"\n%(e)s'))
+        if mbox is None:
+            mbox = mlist.ArchiveFileName()
+
+        i18n.set_language(mlist.preferred_language)
+        # lay claim to the archive's lock file.  this is so no other post can
+        # mess up the archive while we're glomming it.  we pick a suitably
+        # long period of time for the lock lifetime, however we really don't
+        # know how long it will take.
+        #
+        # XXX: processUnixMailbox() should refresh the lock.
+        #
+        # XXX: this may not be necessary because I think we lay claim to the
+        # list lock up above, although that may be too short to be of use (and
+        # maybe we don't really want to lock the list anyway).
+        #
+        lockfile = os.path.join(mm_cfg.LOCK_DIR, mlist._internal_name) + \
+                   '.archiver.lock'
+        # set the lock lifetime to 3 hours.  XXX is this reasonable???
+        lock = LockFile(lockfile, lifetime=3*60*60)
+        lock.lock()
+        # Maybe wipe the old archives
+        if wipe:
+            shutil.rmtree(mlist.archive_dir())
+        try:
+            fp = open(mbox)
+        except IOError, msg:
+            usage(3, _('Cannot open mbox file %(mbox)s: %(msg)s'))
+
+        archiver = HyperArchive(mlist)
+        archiver.VERBOSE = verbose
+        try:
+            archiver.processUnixMailbox(fp, start, end)
+        finally:
+            archiver.close()
+        fp.close()
+    finally:
+        if lock:
+            lock.unlock()
+        if mlist:
+            mlist.Unlock()
+
+
+if __name__ == '__main__':
+    main()
diff --git a/bin/b4b5-archfix b/bin/b4b5-archfix
new file mode 100644
index 00000000..0ae66c9d
--- /dev/null
+++ b/bin/b4b5-archfix
@@ -0,0 +1,96 @@
+#! @PYTHON@
+#
+# Copyright (C) 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.
+
+"""Fix the MM2.1b4 archives.
+
+Usage: %(PROGRAM)s [options] file ...
+
+Where options are:
+    -h / --help
+        Print this help message and exit.
+
+Only use this to `fix' some archive database files that may have gotten
+written in Mailman 2.1b4 with some bogus data.  Use like this from your
+$PREFIX directory
+
+%% %(PROGRAM)s `grep -l _mlist archives/private/*/database/*-article`
+
+(note the backquotes are required)
+
+You will need to run `bin/check_perms -f' after running this script.
+"""
+# This script is provided for convenience purposes only.  It isn't supported.
+
+import os
+import sys
+import getopt
+import marshal
+import cPickle as pickle
+
+# Required to get the right classes for unpickling
+import paths
+from Mailman.i18n import _
+
+PROGRAM = sys.argv[0]
+
+
+
+def usage(code, msg=''):
+    if code:
+        fd = sys.stderr
+    else:
+        fd = sys.stdout
+    print >> fd, _(__doc__)
+    if msg:
+        print >> fd, msg
+    sys.exit(code)
+
+
+
+def main():
+    # get command line arguments
+    try:
+        opts, args = getopt.getopt(sys.argv[1:], 'h', ['help'])
+    except getopt.error, msg:
+        usage(1, msg)
+
+    for opt, arg in opts:
+        if opt in ('-h', '--help'):
+            usage(0)
+
+    for filename in args:
+        print 'processing:', filename
+        fp = open(filename, 'rb')
+        d = marshal.load(fp)
+        fp.close()
+        newd = {}
+        for key, pckstr in d.items():
+            article = pickle.loads(pckstr)
+            newd[key] = pickle.dumps(article)
+        fp = open(filename + '.tmp', 'wb')
+        marshal.dump(newd, fp)
+        fp.close()
+        os.rename(filename, filename + '.bak')
+        os.rename(filename + '.tmp', filename)
+
+    print 'You should now run "bin/check_perms -f"'
+
+
+
+if __name__ == '__main__':
+    main()
diff --git a/bin/change_pw b/bin/change_pw
new file mode 100644
index 00000000..0e365e08
--- /dev/null
+++ b/bin/change_pw
@@ -0,0 +1,209 @@
+#! @PYTHON@
+#
+# Copyright (C) 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.
+
+"""Change a list's password.
+
+Prior to Mailman 2.1, list passwords were kept in crypt'd format -- usually.
+Some Python installations didn't have the crypt module available, so they'd
+fall back to md5.  Then suddenly the Python installation might grow a crypt
+module and all list passwords would be broken.
+
+In Mailman 2.1, all list and site passwords are stored in SHA1 hexdigest
+form.  This breaks list passwords for all existing pre-Mailman 2.1 lists, and
+since those passwords aren't stored anywhere in plain text, they cannot be
+retrieved and updated.
+
+Thus, this script generates new passwords for a list, and optionally sends it
+to all the owners of the list.
+
+Usage: change_pw [options]
+
+Options:
+
+    --all / -a
+        Change the password for all lists.
+
+    --domain=domain
+    -d domain
+        Change the password for all lists in the virtual domain `domain'.  It
+        is okay to give multiple -d options.
+
+    --listname=listname
+    -l listname
+        Change the password only for the named list.  It is okay to give
+        multiple -l options.
+
+    --password=newpassword
+    -p newpassword
+        Use the supplied plain text password `newpassword' as the new password
+        for any lists that are being changed (as specified by the -a, -d, and
+        -l options).  If not given, lists will be assigned a randomly
+        generated new password.
+
+    --quiet / -q
+        Don't notify list owners of the new password.  You'll have to have
+        some other way of letting the list owners know the new password
+        (presumably out-of-band).
+
+    --help / -h
+        Print this help message and exit.
+"""
+
+import sys
+import sha
+import getopt
+
+import paths
+from Mailman import mm_cfg
+from Mailman import Utils
+from Mailman import MailList
+from Mailman import Errors
+from Mailman import Message
+from Mailman import i18n
+
+_ = i18n._
+
+SPACE = ' '
+
+
+
+def usage(code, msg=''):
+    if code:
+        fd = sys.stderr
+    else:
+        fd = sys.stdout
+    print >> fd, _(__doc__)
+    if msg:
+        print >> fd, msg
+    sys.exit(code)
+
+
+
+_listcache = {}
+
+def openlist(listname):
+    missing = []
+    mlist = _listcache.get(listname, missing)
+    if mlist is missing:
+        try:
+            mlist = MailList.MailList(listname, lock=0)
+        except Errors.MMListError, e:
+            usage(1, _('No such list "%(listname)s"\n%(e)s'))
+        _listcache[listname] = mlist
+    return mlist
+
+
+
+def main():
+    # Parse options
+    try:
+        opts, args = getopt.getopt(
+            sys.argv[1:], 'ad:l:p:qh',
+            ['all', 'domain=', 'listname=', 'password=', 'quiet', 'help'])
+    except getopt.error, msg:
+        usage(1, msg)
+
+    # defaults
+    listnames = {}
+    domains = {}
+    password = None
+    quiet = 0
+    
+    for opt, arg in opts:
+        if opt in ('-h', '--help'):
+            usage(0)
+        elif opt in ('-a', '--all'):
+            for name in Utils.list_names():
+                listnames[name] = 1
+        elif opt in ('-d', '--domain'):
+            domains[arg] = 1
+        elif opt in ('-l', '--listname'):
+            listnames[arg] = 1
+        elif opt in ('-p', '--password'):
+            password = arg
+        elif opt in ('-q', '--quiet'):
+            quiet = 1
+
+    if args:
+        strargs = SPACE.join(args)
+        usage(1, _('Bad arguments: %(strargs)s'))
+    
+    if password is not None:
+        if not password:
+            usage(1, _('Empty list passwords are not allowed'))
+        shapassword = sha.new(password).hexdigest()
+
+    if domains:
+        for name in Utils.list_names():
+            mlist = openlist(name)
+            if domains.has_key(mlist.host_name):
+                listnames[name] = 1
+
+    if not listnames:
+        print >> sys.stderr, _('Nothing to do.')
+        sys.exit(0)
+
+    # Set the password on the lists
+    for listname in listnames.keys():
+        mlist = openlist(listname)
+        mlist.Lock()
+        try:
+            if password is None:
+                randompw = Utils.MakeRandomPassword(8)
+                shapassword = sha.new(randompw).hexdigest()
+                notifypassword = randompw
+            else:
+                notifypassword = password
+
+            mlist.password = shapassword
+            mlist.Save()
+        finally:
+            mlist.Unlock()
+
+        # Notification
+        print _('New %(listname)s password: %(notifypassword)s')
+        if not quiet:
+            otrans = i18n.get_translation()
+            i18n.set_language(mlist.preferred_language)
+            try:
+                hostname = mlist.host_name
+                adminurl = mlist.GetScriptURL('admin', absolute=1)
+                msg = Message.UserNotification(
+                    mlist.owner[:], Utils.get_site_email(),
+                    _('Your new %(listname)s list password'),
+                    _('''\
+The site administrator at %(hostname)s has changed the password for your
+mailing list %(listname)s.  It is now
+
+    %(notifypassword)s
+
+Please be sure to use this for all future list administration.  You may want
+to log in now to your list and change the password to something more to your
+liking.  Visit your list admin page at
+
+    %(adminurl)s
+'''),
+                    mlist.preferred_language)
+            finally:
+                i18n.set_translation(otrans)
+            msg.send(mlist)
+
+
+
+if __name__ == '__main__':
+    main()
diff --git a/bin/check_db b/bin/check_db
new file mode 100755
index 00000000..c869b194
--- /dev/null
+++ b/bin/check_db
@@ -0,0 +1,153 @@
+#! @PYTHON@
+#
+# 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.
+
+"""Check a list's config database file for integrity.
+
+All of the following files are checked:
+
+    config.pck
+    config.pck.last
+    config.db
+    config.db.last
+    config.safety
+
+It's okay if any of these are missing.  config.pck and config.pck.last are
+pickled versions of the config database file for 2.1a3 and beyond.  config.db
+and config.db.last are used in all earlier versions, and these are Python
+marshals.  config.safety is a pickle written by 2.1a3 and beyond when the
+primary config.pck file could not be read.
+
+Usage: %(PROGRAM)s [options] [listname [listname ...]]
+
+Options:
+
+    --all / -a
+        Check the databases for all lists.  Otherwise only the lists named on
+        the command line are checked.
+
+    --verbose / -v
+        Verbose output.  The state of every tested file is printed.
+        Otherwise only corrupt files are displayed.
+
+    --help / -h
+        Print this text and exit.
+"""
+
+import sys
+import os
+import errno
+import getopt
+import marshal
+import cPickle
+
+import paths
+from Mailman import mm_cfg
+from Mailman import Utils
+from Mailman.MailList import MailList
+from Mailman.i18n import _
+
+PROGRAM = sys.argv[0]
+
+
+
+def usage(code, msg=''):
+    if code:
+        fd = sys.stderr
+    else:
+        fd = sys.stdout
+    print >> fd, _(__doc__)
+    if msg:
+        print >> fd, msg
+    sys.exit(code)
+
+
+
+def testfile(dbfile):
+    if dbfile.endswith('.db') or dbfile.endswith('.db.last'):
+        loadfunc = marshal.load
+    elif dbfile.endswith('.pck') or dbfile.endswith('.pck.last'):
+        loadfunc = cPickle.load
+    else:
+        assert 0
+    fp = open(dbfile)
+    try:
+        loadfunc(fp)
+    finally:
+        fp.close()
+
+
+def main():
+    try:
+        opts, args = getopt.getopt(sys.argv[1:], 'ahv',
+                                   ['all', 'verbose', 'help'])
+    except getopt.error, msg:
+        usage(1, msg)
+
+    verbose = 0
+    listnames = args
+
+    for opt, arg in opts:
+        if opt in ('-h', '--help'):
+            usage(0)
+        elif opt in ('-v', '--verbose'):
+            verbose = 1
+        elif opt in ('-a', '--all'):
+            listnames = Utils.list_names()
+
+    listnames = [n.lower().strip() for n in listnames]
+    if not listnames:
+        print _('Nothing to do.')
+        sys.exit(0)
+
+    for listname in listnames:
+        if not Utils.list_exists(listname):
+            print _('No list named:'), listname
+            continue
+        mlist = MailList(listname, lock=0)
+        pfile = os.path.join(mlist.fullpath(), 'config.pck')
+        plast = pfile + '.last'
+        dfile = os.path.join(mlist.fullpath(), 'config.db')
+        dlast = dfile + '.last'
+
+        if verbose:
+            print _('List:'), listname
+
+        for file in (pfile, plast, dfile, dlast):
+            status = 0
+            try:
+                testfile(file)
+            except IOError, e:
+                # Don't report ENOENT unless we're in verbose mode
+                if verbose or e.errno <> errno.ENOENT:
+                    status = e
+            except Exception, e:
+                status = e
+            # Report errors
+            if status:
+                if isinstance(status, EnvironmentError):
+                    # This already includes the file name
+                    print '   ', status
+                else:
+                    print '    %s: %s' % (file, status)
+            elif verbose:
+                print _('   %(file)s: okay')
+
+
+
+if __name__ == '__main__':
+    main()
diff --git a/bin/check_perms b/bin/check_perms
new file mode 100755
index 00000000..44fbe547
--- /dev/null
+++ b/bin/check_perms
@@ -0,0 +1,362 @@
+#! @PYTHON@
+#
+# 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.
+
+"""Check the permissions for the Mailman installation.
+
+Usage: %(PROGRAM)s [-f] [-v] [-h]
+
+With no arguments, just check and report all the files that have bogus
+permissions or group ownership.  With -f (and run as root), fix all the
+permission problems found.  With -v be verbose.
+
+"""
+
+import sys
+import os
+import errno
+import getopt
+import pwd
+import grp
+from stat import *
+
+try:
+    import paths
+except ImportError:
+    print '''Could not import paths!
+
+This probably means that you are trying to run check_perms from the source
+directory.  You must run this from the installation directory instead.
+'''
+    raise
+from Mailman import mm_cfg
+from Mailman.mm_cfg import MAILMAN_USER, MAILMAN_GROUP
+from Mailman.i18n import _
+
+# Let KeyErrors percolate
+MAILMAN_GID = grp.getgrnam(MAILMAN_GROUP)[2]
+MAILMAN_UID = pwd.getpwnam(MAILMAN_USER)[2]
+
+PROGRAM = sys.argv[0]
+
+# Gotta check the archives/private/*/database/* files
+
+
+
+class State:
+    FIX = 0
+    VERBOSE = 0
+    ERRORS = 0
+
+STATE = State()
+
+DIRPERMS = S_ISGID | S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH
+QFILEPERMS = S_ISGID | S_IRWXU | S_IRWXG
+PYFILEPERMS = S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH
+ARTICLEFILEPERMS = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP
+
+
+
+def statmode(path):
+    return os.stat(path)[ST_MODE]
+
+def statgidmode(path):
+    stat = os.stat(path)
+    return stat[ST_MODE], stat[ST_GID]
+
+def checkwalk(arg, dirname, names):
+    for name in names:
+        path = os.path.join(dirname, name)
+        if arg.VERBOSE:
+            print _('    checking gid and mode for %(path)s')
+        try:
+            mode, gid = statgidmode(path)
+        except OSError, e:
+            if e.errno <> errno.ENOENT: raise
+            continue
+        if gid <> MAILMAN_GID:
+            try:
+                groupname = grp.getgrgid(gid)[0]
+            except KeyError:
+                groupname = '<anon gid %d>' % gid
+            arg.ERRORS += 1
+            print _('%(path)s bad group (has: %(groupname)s, '
+                    'expected %(MAILMAN_GROUP)s)'),
+            if STATE.FIX:
+                print _('(fixing)')
+                os.chown(path, -1, MAILMAN_GID)
+            else:
+                print
+        # all directories must be at least rwxrwsr-x.  Don't check the private
+        # archive directory or database directory themselves since these are
+        # checked in checkarchives() and checkarchivedbs() below.
+        private = mm_cfg.PRIVATE_ARCHIVE_FILE_DIR
+        if path == private or (os.path.commonprefix((path, private)) == private
+                               and os.path.split(path)[1] == 'database'):
+            continue
+        # The directories under qfiles should have a more limited permission
+        if os.path.commonprefix((path, mm_cfg.QUEUE_DIR)) == mm_cfg.QUEUE_DIR:
+            targetperms = QFILEPERMS
+            octperms = oct(targetperms)
+        else:
+            targetperms = DIRPERMS
+            octperms = oct(targetperms)
+        if S_ISDIR(mode) and (mode & targetperms) <> targetperms:
+            arg.ERRORS += 1
+            print _('directory permissions must be %(octperms)s: %(path)s'),
+            if STATE.FIX:
+                print _('(fixing)')
+                os.chmod(path, mode | targetperms)
+            else:
+                print
+        elif os.path.splitext(path)[1] in ('.py', '.pyc', '.pyo'):
+            octperms = oct(PYFILEPERMS)
+            if mode & PYFILEPERMS <> PYFILEPERMS:
+                print _('source perms must be %(octperms)s: %(path)s'),
+                arg.ERRORS += 1
+                if STATE.FIX:
+                    print _('(fixing)')
+                    os.chmod(path, mode | PYFILEPERMS)
+                else:
+                    print
+        elif path.endswith('-article'):
+            # Article files must be group writeable
+            octperms = oct(ARTICLEFILEPERMS)
+            if mode & ARTICLEFILEPERMS <> ARTICLEFILEPERMS:
+                print _('article db files must be %(octperms)s: %(path)s'),
+                arg.ERRORS += 1
+                if STATE.FIX:
+                    print _('(fixing)')
+                    os.chmod(path, mode | ARTICLEFILEPERMS)
+                else:
+                    print
+
+def checkall():
+    # first check PREFIX
+    if STATE.VERBOSE:
+        prefix = mm_cfg.PREFIX
+        print _('checking mode for %(prefix)s')
+    dirs = {}
+    for d in (mm_cfg.PREFIX, mm_cfg.EXEC_PREFIX, mm_cfg.VAR_PREFIX):
+        dirs[d] = 1
+    for d in dirs.keys():
+        mode = statmode(d)
+        if (mode & DIRPERMS) <> DIRPERMS:
+            STATE.ERRORS += 1
+            print _('directory must be at least 02775: %(d)s'),
+            if STATE.FIX:
+                print _('(fixing)')
+                os.chmod(d, mode | DIRPERMS)
+            else:
+                print
+        # check all subdirs
+        os.path.walk(d, checkwalk, STATE)
+
+
+def checkarchives():
+    private = mm_cfg.PRIVATE_ARCHIVE_FILE_DIR
+    if STATE.VERBOSE:
+        print _('checking perms on %(private)s')
+    # private archives must not be other readable
+    mode = statmode(private)
+    if mode & S_IROTH:
+        STATE.ERRORS += 1
+        print _('%(private)s must not be other-readable'),
+        if STATE.FIX:
+            print _('(fixing)')
+            os.chmod(private, mode & ~S_IROTH)
+        else:
+            print
+
+
+MBOXPERMS = S_IRGRP | S_IWGRP | S_IRUSR | S_IWUSR
+
+
+def checkmboxfile(mboxdir):
+    absdir = os.path.join(mm_cfg.PRIVATE_ARCHIVE_FILE_DIR, mboxdir)
+    for f in os.listdir(absdir):
+        if not f.endswith('.mbox'):
+            continue
+        mboxfile = os.path.join(absdir, f)
+        mode = statmode(mboxfile)
+        if (mode & MBOXPERMS) <> MBOXPERMS:
+            STATE.ERRORS = STATE.ERRORS + 1
+            print _('mbox file must be at least 0660:'), mboxfile
+            if STATE.FIX:
+                print _('(fixing)')
+                os.chmod(mboxfile, mode | MBOXPERMS)
+            else:
+                print
+
+
+def checkarchivedbs():
+    # The archives/private/listname/database file must not be other readable
+    # or executable otherwise those files will be accessible when the archives
+    # are public.  That may not be a horrible breach, but let's close this off
+    # anyway.
+    for dir in os.listdir(mm_cfg.PRIVATE_ARCHIVE_FILE_DIR):
+        if dir.endswith('.mbox'):
+            checkmboxfile(dir)
+        dbdir = os.path.join(mm_cfg.PRIVATE_ARCHIVE_FILE_DIR, dir, 'database')
+        try:
+            mode = statmode(dbdir)
+        except OSError, e:
+            if e.errno not in (errno.ENOENT, errno.ENOTDIR): raise
+            continue
+        if mode & S_IRWXO:
+            STATE.ERRORS += 1
+            print _('%(dbdir)s "other" perms must be 000'),
+            if STATE.FIX:
+                print _('(fixing)')
+                os.chmod(dbdir, mode & ~S_IRWXO)
+            else:
+                print
+
+
+def checkcgi():
+    cgidir = os.path.join(mm_cfg.EXEC_PREFIX, 'cgi-bin')
+    if STATE.VERBOSE:
+        print _('checking cgi-bin permissions')
+    exes = os.listdir(cgidir)
+    for f in exes:
+        path = os.path.join(cgidir, f)
+        if STATE.VERBOSE:
+            print _('    checking set-gid for %(path)s')
+        mode = statmode(path)
+        if mode & S_IXGRP and not mode & S_ISGID:
+            STATE.ERRORS += 1
+            print _('%(path)s must be set-gid'),
+            if STATE.FIX:
+                print _('(fixing)')
+                os.chmod(path, mode | S_ISGID)
+            else:
+                print
+
+def checkmail():
+    wrapper = os.path.join(mm_cfg.WRAPPER_DIR, 'mailman')
+    if STATE.VERBOSE:
+        print _('checking set-gid for %(wrapper)s')
+    mode = statmode(wrapper)
+    if not mode & S_ISGID:
+        STATE.ERRORS += 1
+        print _('%(wrapper)s must be set-gid'),
+        if STATE.FIX:
+            print _('(fixing)')
+            os.chmod(wrapper, mode | S_ISGID)
+
+def checkadminpw():
+    for pwfile in (os.path.join(mm_cfg.DATA_DIR, 'adm.pw'),
+                   os.path.join(mm_cfg.DATA_DIR, 'creator.pw')):
+        targetmode = S_IFREG | S_IRUSR | S_IWUSR | S_IRGRP
+        if STATE.VERBOSE:
+            print _('checking permissions on %(pwfile)s')
+        try:
+            mode = statmode(pwfile)
+        except OSError, e:
+            if e.errno <> errno.ENOENT: raise
+            return
+        if mode <> targetmode:
+            STATE.ERRORS += 1
+            octmode = oct(mode)
+            print _('%(pwfile)s permissions must be exactly 0640 '
+                    '(got %(octmode)s)'),
+            if STATE.FIX:
+                print _('(fixing)')
+                os.chmod(pwfile, targetmode)
+            else:
+                print
+
+def checkmta():
+    if mm_cfg.MTA:
+        modname = 'Mailman.MTA.' + mm_cfg.MTA
+        __import__(modname)
+        try:
+            sys.modules[modname].checkperms(STATE)
+        except AttributeError:
+            pass
+
+def checkdata():
+    targetmode = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP
+    checkfiles = ('config.pck', 'config.pck.last',
+                  'config.db', 'config.db.last',
+                  'next-digest', 'next-digest-topics',
+                  'request.db', 'request.db.tmp')
+    if STATE.VERBOSE:
+        print _('checking permissions on list data')
+    # BAW: This needs to be converted to the Site module abstraction
+    for dir in os.listdir(mm_cfg.LIST_DATA_DIR):
+        for file in checkfiles:
+            path = os.path.join(mm_cfg.LIST_DATA_DIR, dir, file)
+            if STATE.VERBOSE:
+                print _('    checking permissions on: %(path)s')
+            try:
+                mode = statmode(path)
+            except OSError, e:
+                if e.errno <> errno.ENOENT: raise
+                continue
+            if (mode & targetmode) <> targetmode:
+                STATE.ERRORS += 1
+                print _('file permissions must be at least 660: %(path)s'),
+                if STATE.FIX:
+                    print _('(fixing)')
+                    os.chmod(path, mode | targetmode)
+                else:
+                    print
+
+
+
+def usage(code, msg=''):
+    if code:
+        fd = sys.stderr
+    else:
+        fd = sys.stdout
+    print >> fd, _(__doc__)
+    if msg:
+        print >> fd, msg
+    sys.exit(code)
+
+
+if __name__ == '__main__':
+    try:
+        opts, args = getopt.getopt(sys.argv[1:],
+                                   'fvh',
+                                   ['fix', 'verbose', 'help'])
+    except getopt.error, msg:
+        usage(1, msg)
+
+    for opt, arg in opts:
+        if opt in ('-h', '--help'):
+            usage(0)
+        elif opt in ('-f', '--fix'):
+            STATE.FIX = 1
+        elif opt in ('-v', '--verbose'):
+            STATE.VERBOSE = 1
+
+    checkall()
+    checkarchives()
+    checkarchivedbs()
+    checkcgi()
+    checkmail()
+    checkdata()
+    checkadminpw()
+    checkmta()
+
+    if not STATE.ERRORS:
+        print _('No problems found')
+    else:
+        print _('Problems found:'), STATE.ERRORS
+        print _('Re-run as %(MAILMAN_USER)s (or root) with -f flag to fix')
diff --git a/bin/cleanarch b/bin/cleanarch
new file mode 100644
index 00000000..85a8df6a
--- /dev/null
+++ b/bin/cleanarch
@@ -0,0 +1,165 @@
+#! @PYTHON@
+
+# Copyright (C) 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.
+
+"""Clean up an .mbox archive file.
+
+The archiver looks for Unix-From lines separating messages in an mbox archive
+file.  For compatibility, it specifically looks for lines that start with
+"From " -- i.e. the letters capital-F, lowercase-r, o, m, space, ignoring
+everything else on the line.
+
+Normally, any lines that start "From " in the body of a message should be
+escaped such that a > character is actually the first on a line.  It is
+possible though that body lines are not actually escaped.  This script
+attempts to fix these by doing a stricter test of the Unix-From lines.  Any
+lines that start "From " but do not pass this stricter test are escaped with a
+> character.
+
+Usage: cleanarch [options] < inputfile > outputfile
+Options:
+    -s n
+    --status=n
+        Print a # character every n lines processed
+
+    -q / --quiet
+        Don't print changed line information to standard error.
+
+    -n / --dry-run
+        Don't actually output anything.
+
+    -h / --help
+        Print this message and exit
+"""
+
+import sys
+import re
+import getopt
+import mailbox
+
+import paths
+from Mailman.i18n import _
+
+cre = re.compile(mailbox.UnixMailbox._fromlinepattern)
+
+# From RFC 2822, a header field name must contain only characters from 33-126
+# inclusive, excluding colon.  I.e. from oct 41 to oct 176 less oct 072.  Must
+# use re.match() so that it's anchored at the beginning of the line.
+fre = re.compile(r'[\041-\071\073-\0176]+')
+
+
+
+def usage(code, msg=''):
+    if code:
+        fd = sys.stderr
+    else:
+        fd = sys.stdout
+    print >> fd, _(__doc__)
+    if msg:
+        print >> fd, msg
+    sys.exit(code)
+
+
+
+def escape_line(line, lineno, quiet, output):
+    if output:
+        sys.stdout.write('>' + line)
+    if not quiet:
+        print >> sys.stderr, _('Unix-From line changed: %(lineno)d')
+        print >> sys.stderr, line[:-1]
+
+
+
+def main():
+    try:
+        opts, args = getopt.getopt(
+            sys.argv[1:], 'hqns:',
+            ['help', 'quiet', 'dry-run', 'status='])
+    except getopt.error, msg:
+        usage(1, msg)
+
+    quiet = 0
+    output = 1
+    status = -1
+
+    for opt, arg in opts:
+        if opt in ('-h', '--help'):
+            usage(0)
+        elif opt in ('-q', '--quiet'):
+            quiet = 1
+        elif opt in ('-n', '--dry-run'):
+            output = 0
+        elif opt in ('-s', '--status'):
+            try:
+                status = int(arg)
+            except ValueError:
+                usage(1, _('Bad status number: %(arg)s'))
+
+    if args:
+        usage(1)
+
+    lineno = 0
+    statuscnt = 0
+    messages = 0
+    while 1:
+        lineno += 1
+        line = sys.stdin.readline()
+        if not line:
+            break
+        if line.startswith('From '):
+            if cre.match(line):
+                # This is a real Unix-From line.  But it could be a message
+                # /about/ Unix-From lines, so as a second order test, make
+                # sure there's at least one RFC 2822 header following
+                nextline = sys.stdin.readline()
+                lineno += 1
+                if not nextline:
+                    # It was the last line of the mbox, so it couldn't have
+                    # been a Unix-From
+                    escape_line(line, lineno, quiet, output)
+                    break
+                fieldname = nextline.split(':', 1)
+                if len(fieldname) < 2 or not fre.match(nextline):
+                    # The following line was not a header, so this wasn't a
+                    # valid Unix-From
+                    escape_line(line, lineno, quiet, output)
+                    if output:
+                        sys.stdout.write(nextline)
+                else:
+                    # It's a valid Unix-From line
+                    messages += 1
+                    if output:
+                        sys.stdout.write(line)
+                        sys.stdout.write(nextline)
+            else:
+                # This is a bogus Unix-From line
+                escape_line(line, lineno, quiet, output)
+        elif output:
+            # Any old line
+            sys.stdout.write(line)
+        if status > 0 and (lineno % status) == 0:
+            sys.stderr.write('#')
+            statuscnt += 1
+            if statuscnt > 50:
+                print >> sys.stderr
+                statuscnt = 0
+    print >> sys.stderr, _('%(messages)d messages found')
+
+
+
+if __name__ == '__main__':
+    main()
diff --git a/bin/clone_member b/bin/clone_member
new file mode 100755
index 00000000..5861aff5
--- /dev/null
+++ b/bin/clone_member
@@ -0,0 +1,219 @@
+#! @PYTHON@
+#
+# 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.
+
+"""Clone a member address.
+
+Cloning a member address means that a new member will be added who has all the
+same options and passwords as the original member address.  Note that this
+operation is fairly trusting of the user who runs it -- it does no
+verification to the new address, it does not send out a welcome message, etc.
+
+The existing member's subscription is usually not modified in any way.  If you
+want to remove the old address, use the -r flag.  If you also want to change
+any list admin addresses, use the -a flag.
+
+Usage:
+    clone_member [options] fromoldaddr tonewaddr
+
+Where:
+
+    --listname=listname
+    -l listname
+        Check and modify only the named mailing lists.  If -l is not given,
+        then all mailing lists are scanned from the address.  Multiple -l
+        options can be supplied.
+
+    --remove
+    -r
+        Remove the old address from the mailing list after it's been cloned.
+
+    --admin
+    -a
+        Scan the list admin addresses for the old address, and clone or change
+        them too.
+
+    --quiet
+    -q
+        Do the modifications quietly.
+
+    --nomodify
+    -n
+        Print what would be done, but don't actually do it.  Inhibits the
+        --quiet flag.
+
+    --help
+    -h
+        Print this help message and exit.
+
+ fromoldaddr (`from old address') is the old address of the user.  tonewaddr
+ (`to new address') is the new address of the user.
+
+"""
+
+import sys
+import getopt
+
+import paths
+from Mailman import MailList
+from Mailman import Utils
+from Mailman import Errors
+from Mailman.i18n import _
+
+
+
+def usage(code, msg=''):
+    if code:
+        fd = sys.stderr
+    else:
+        fd = sys.stdout
+    print >> fd, _(__doc__)
+    if msg:
+        print >> fd, msg
+    sys.exit(code)
+
+
+
+def dolist(mlist, options):
+    SPACE = ' '
+    if not options.quiet:
+        print _('processing mailing list:'), mlist.internal_name()
+
+    # scan the list owners.  TBD: mlist.owner keys should be lowercase?
+    oldowners = mlist.owner[:]
+    oldowners.sort()
+    if options.admintoo:
+        if not options.quiet:
+            print _('    scanning list owners:'), SPACE.join(oldowners)
+        newowners = {}
+        foundp = 0
+        for owner in mlist.owner:
+            if options.lfromaddr == owner.lower():
+                foundp = 1
+                if options.remove:
+                    continue
+            newowners[owner] = 1
+        if foundp:
+            newowners[options.toaddr] = 1 
+        newowners = newowners.keys()
+        newowners.sort()
+        if options.modify:
+            mlist.owner = newowners
+        if not options.quiet:
+            if newowners <> oldowners:
+                print
+                print _('    new list owners:'), SPACE.join(newowners)
+            else:
+                print _('(no change)')
+
+    # see if the fromaddr is a digest member or regular member
+    if options.lfromaddr in mlist.getDigestMemberKeys():
+        digest = 1
+    elif options.lfromaddr in mlist.getRegularMemberKeys():
+        digest = 0
+    else:
+        if not options.quiet:
+            print _('    address not found:'), options.fromaddr
+        return
+
+    # Now change the membership address
+    try:
+        if options.modify:
+            mlist.changeMemberAddress(options.fromaddr, options.toaddr,
+                                      not options.remove)
+        if not options.quiet:
+            print _('    clone address added:'), options.toaddr
+    except Errors.MMAlreadyAMember:
+        if not options.quiet:
+            print _('    clone address is already a member:'), options.toaddr
+
+    if options.remove:
+        print _('    original address removed:'), options.fromaddr
+
+
+
+def main():
+    # default options
+    class Options:
+        listnames = None
+        remove = 0
+        admintoo = 0
+        quiet = 0
+        modify = 1
+
+    # scan sysargs
+    try:
+        opts, args = getopt.getopt(
+            sys.argv[1:], 'arl:qnh',
+            ['admin', 'remove', 'listname=', 'quiet', 'nomodify', 'help'])
+    except getopt.error, msg:
+        usage(1, msg)
+
+    options = Options()
+    for opt, arg in opts:
+        if opt in ('-h', '--help'):
+            usage(0)
+        elif opt in ('-q', '--quiet'):
+            options.quiet = 1
+        elif opt in ('-n', '--nomodify'):
+            options.modify = 0
+        elif opt in ('-a', '--admin'):
+            options.admintoo = 1
+        elif opt in ('-r', '--remove'):
+            options.remove = 1
+        elif opt in ('-l', '--listname'):
+            if options.listnames is None:
+                options.listnames = []
+            options.listnames.append(arg.lower())
+
+    # further options and argument processing
+    if not options.modify:
+        options.quiet = 0
+
+    if len(args) <> 2:
+        usage(1)
+    fromaddr = args[0]
+    toaddr = args[1]
+        
+    # validate and normalize the target address
+    try:
+        Utils.ValidateEmail(toaddr)
+    except Errors.EmailAddressError:
+        usage(1, _('Not a valid email address: %(toaddr)s'))
+    lfromaddr = fromaddr.lower()
+    options.toaddr = toaddr
+    options.fromaddr = fromaddr
+    options.lfromaddr = lfromaddr
+
+    if options.listnames is None:
+        options.listnames = Utils.list_names()
+
+    for listname in options.listnames:
+        try:
+            mlist = MailList.MailList(listname)
+        except Errors.MMListError, e:
+            print _('Error opening list "%(listname)s", skipping.\n%(e)s')
+            continue
+        try:
+            dolist(mlist, options)
+        finally:
+            mlist.Save()
+            mlist.Unlock()
+
+
+if __name__ == '__main__':
+    main()
diff --git a/bin/config_list b/bin/config_list
new file mode 100644
index 00000000..9675e142
--- /dev/null
+++ b/bin/config_list
@@ -0,0 +1,339 @@
+#! @PYTHON@
+#
+# 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.
+
+"""Configure a list from a text file description.
+
+Usage: config_list [options] listname
+
+Options:
+    --inputfile filename
+    -i filename
+        Configure the list by assigning each module-global variable in the
+        file to an attribute on the list object, then saving the list.  The
+        named file is loaded with execfile() and must be legal Python code.
+        Any variable that isn't already an attribute of the list object is
+        ignored (a warning message is printed).  See also the -c option.
+
+        A special variable named `mlist' is put into the globals during the
+        execfile, which is bound to the actual MailList object.  This lets you
+        do all manner of bizarre thing to the list object, but BEWARE!  Using
+        this can severely (and possibly irreparably) damage your mailing list!
+
+    --outputfile filename
+    -o filename
+        Instead of configuring the list, print out a list's configuration
+        variables in a format suitable for input using this script.  In this
+        way, you can easily capture the configuration settings for a
+        particular list and imprint those settings on another list.  filename
+        is the file to output the settings to.  If filename is `-', standard
+        out is used.
+
+    --checkonly
+    -c
+        With this option, the modified list is not actually changed.  Only
+        useful with -i.
+
+    --verbose
+    -v
+        Print the name of each attribute as it is being changed.  Only useful
+        with -i.
+
+    --help
+    -h
+        Print this help message and exit.
+
+The options -o and -i are mutually exclusive.
+
+"""
+
+import sys
+import re
+import time
+import getopt
+from types import TupleType
+
+import paths
+from Mailman import mm_cfg
+from Mailman import MailList
+from Mailman import Utils
+from Mailman import Errors
+from Mailman.i18n import _
+
+NL = '\n'
+
+
+
+def usage(code, msg=''):
+    if code:
+        fd = sys.stderr
+    else:
+        fd = sys.stdout
+    print >> fd, _(__doc__)
+    if msg:
+        print >> fd, msg
+    sys.exit(code)
+
+
+
+def do_output(listname, outfile):
+    closep = 0
+    try:
+        if outfile == '-':
+            outfp = sys.stdout
+        else:
+            outfp = open(outfile, 'w')
+            closep = 1
+        # Open the specified list unlocked, since we're only reading it.
+        try:
+            mlist = MailList.MailList(listname, lock=0)
+        except Errors.MMListError:
+            usage(1, _('No such list: %(listname)s'))
+        # get all the list config info.  all this stuff is accessible via the
+        # web interface
+        when = time.ctime(time.time())
+        print >> outfp, _('''\
+## "%(listname)s" mailing list configuration settings -*- python -*-
+## captured on %(when)s
+''')
+
+        for k in mm_cfg.ADMIN_CATEGORIES:
+            subcats = mlist.GetConfigSubCategories(k)
+            if subcats is None:
+                do_list_categories(mlist, k, None, outfp)
+            else:
+                for subcat in [t[0] for t in subcats]:
+                    do_list_categories(mlist, k, subcat, outfp)
+    finally:
+        if closep:
+            outfp.close()
+
+
+def do_list_categories(mlist, k, subcat, outfp):
+    info = mlist.GetConfigInfo(k, subcat)
+    label, gui = mlist.GetConfigCategories()[k]
+    if info is None:
+        return
+    print >> outfp, '##', k.capitalize(), _('options')
+    print >> outfp, '#'
+    # First, massage the descripton text, which could have obnoxious
+    # leading whitespace on second and subsequent lines due to
+    # triple-quoted string nonsense in the source code.
+    desc = NL.join([s.lstrip() for s in info[0].split('\n')])
+    # Print out the category description
+    desc = Utils.wrap(desc)
+    for line in desc.split('\n'):
+        print >> outfp, '#', line
+    print >> outfp
+    for data in info[1:]:
+        if not isinstance(data, TupleType):
+            continue
+        varname = data[0]
+        # Variable could be volatile
+        if varname[0] == '_':
+            continue
+        vtype = data[1]
+        # First, massage the descripton text, which could have
+        # obnoxious leading whitespace on second and subsequent lines
+        # due to triple-quoted string nonsense in the source code.
+        desc = NL.join([s.lstrip() for s in data[-1].split('\n')])
+        # Now strip out all HTML tags
+        desc = re.sub('<.*?>', '', desc)
+        # And convert &lt;/&gt; to <>
+        desc = re.sub('&lt;', '<', desc)
+        desc = re.sub('&gt;', '>', desc)
+        # Print out the variable description.
+        desc = Utils.wrap(desc)
+        for line in desc.split('\n'):
+            print >> outfp, '#', line
+        # munge the value based on its type
+        value = None
+        if hasattr(gui, 'getValue'):
+            value = gui.getValue(mlist, vtype, varname, data[2])
+        if value is None and not varname.startswith('_'):
+            value = getattr(mlist, varname)
+        if vtype in (mm_cfg.Text, mm_cfg.FileUpload):
+            print >> outfp, varname, '=',
+            lines = value.splitlines()
+            if not lines:
+                print >> outfp, "''"
+            elif len(lines) == 1:
+                print >> outfp, repr(lines[0])
+            else:
+                first = 1
+                outfp.write(' """')
+                for line in lines:
+                    if first:
+                        first = 0
+                    else:
+                        print >> outfp
+                    outfp.write(line.replace('"', '\\"'))
+                print >> outfp, '"""'
+        elif vtype in (mm_cfg.Radio, mm_cfg.Toggle):
+            print >> outfp, '#'
+            print >> outfp, '#', _('legal values are:')
+            # TBD: This is disgusting, but it's special cased
+            # everywhere else anyway...
+            if varname == 'subscribe_policy' and \
+                   not mm_cfg.ALLOW_OPEN_SUBSCRIBE:
+                i = 1
+            else:
+                i = 0
+            for choice in data[2]:
+                print >> outfp, '#   ', i, '= "%s"' % choice
+                i += 1
+            print >> outfp, varname, '=', repr(value)
+        else:
+            print >> outfp, varname, '=', repr(value)
+        print >> outfp
+
+
+
+def getPropertyMap(mlist):
+    guibyprop = {}
+    categories = mlist.GetConfigCategories()
+    for category, (label, gui) in categories.items():
+        if not hasattr(gui, 'GetConfigInfo'):
+            continue
+        subcats = mlist.GetConfigSubCategories(category)
+        if subcats is None:
+            subcats = [(None, None)]
+        for subcat, sclabel in subcats:
+            for element in gui.GetConfigInfo(mlist, category, subcat):
+                if not isinstance(element, TupleType):
+                    continue
+                propname = element[0]
+                wtype = element[1]
+                guibyprop[propname] = (gui, wtype)
+    return guibyprop
+
+
+class FakeDoc:
+    # Fake the error reporting API for the htmlformat.Document class
+    def addError(self, s, tag=None, *args):
+        if tag:
+            print >> sys.stderr, tag
+        print >> sys.stderr, s % args
+
+    def set_language(self, val):
+        pass
+
+
+def do_input(listname, infile, checkonly, verbose):
+    fakedoc = FakeDoc()
+    # open the specified list locked, unless checkonly is set
+    try:
+        mlist = MailList.MailList(listname, lock=not checkonly)
+    except Errors.MMListError, e:
+        usage(1, _('No such list "%(listname)s"\n%(e)s'))
+    savelist = 0
+    guibyprop = getPropertyMap(mlist)
+    try:
+        globals = {'mlist': mlist}
+        # Any exception that occurs in execfile() will cause the list to not
+        # be saved, but any other problems are not save-fatal.
+        execfile(infile, globals)
+        savelist = 1
+        for k, v in globals.items():
+            if k in ('mlist', '__builtins__'):
+                continue
+            if not hasattr(mlist, k):
+                print >> sys.stderr, _('attribute "%(k)s" ignored')
+                continue
+            if verbose:
+                print >> sys.stderr, _('attribute "%(k)s" changed')
+            missing = []
+            gui, wtype = guibyprop.get(k, (missing, missing))
+            if gui is missing:
+                # This isn't an official property of the list, but that's
+                # okay, we'll just restore it the old fashioned way
+                print >> sys.stderr, _('Non-standard property restored: %(k)s')
+                setattr(mlist, k, v)
+            else:
+                # BAW: This uses non-public methods.  This logic taken from
+                # the guts of GUIBase.handleForm().
+                try:
+                    validval = gui._getValidValue(mlist, k, wtype, v)
+                except ValueError:
+                    print >> sys.stderr, _('Invalid value for property: %(k)s')
+                except Errors.EmailAddressError:
+                    print >> sys.stderr, _(
+                        'Bad email address for option %(k)s: %(v)s')
+                else:
+                    # BAW: Horrible hack, but then this is special cased
+                    # everywhere anyway. :(  Privacy._setValue() knows that
+                    # when ALLOW_OPEN_SUBSCRIBE is false, the web values are
+                    # 0, 1, 2 but these really should be 1, 2, 3, so it adds
+                    # one.  But we really do provide [0..3] so we need to undo
+                    # the hack that _setValue adds. :( :(
+                    if k == 'subscribe_policy' and \
+                           not mm_cfg.ALLOW_OPEN_SUBSCRIBE:
+                        validval -= 1
+                    gui._setValue(mlist, k, validval, fakedoc)
+            # BAW: when to do gui._postValidate()???
+    finally:
+        if savelist and not checkonly:
+            mlist.Save()
+        mlist.Unlock()
+
+
+
+def main():
+    try:
+        opts, args = getopt.getopt(
+            sys.argv[1:], 'ci:o:vh',
+            ['checkonly', 'inputfile=', 'outputfile=', 'verbose', 'help'])
+    except getopt.error, msg:
+        usage(1, msg)
+
+    # defaults
+    infile = None
+    outfile = None
+    checkonly = 0
+    verbose = 0
+    for opt, arg in opts:
+        if opt in ('-h', '--help'):
+            usage(0)
+        elif opt in ('-o', '--outputfile'):
+            outfile = arg
+        elif opt in ('-i', '--inputfile'):
+            infile = arg
+        elif opt in ('-c', '--checkonly'):
+            checkonly = 1
+        elif opt in ('-v', '--verbose'):
+            verbose = 1
+
+    # sanity check
+    if infile is not None and outfile is not None:
+        usage(1, _('Only one of -i or -o is allowed'))
+    if infile is None and outfile is None:
+        usage(1, _('One of -i or -o is required'))
+
+    # get the list name
+    if len(args) <> 1:
+        usage(1, _('List name is required'))
+    listname = args[0].lower().strip()
+
+    if outfile:
+        do_output(listname, outfile)
+    else:
+        do_input(listname, infile, checkonly, verbose)
+
+
+
+if __name__ == '__main__':
+    main()
diff --git a/bin/convert.py b/bin/convert.py
new file mode 100644
index 00000000..24951b5e
--- /dev/null
+++ b/bin/convert.py
@@ -0,0 +1,44 @@
+#! @PYTHON@
+#
+# Copyright (C) 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.
+
+"""Convert a list's interpolation strings from %-strings to $-strings.
+
+This script is intended to be run as a bin/withlist script, i.e.
+
+% bin/withlist -l -r convert <mylist>
+"""
+
+import paths
+from Mailman import Utils
+from Mailman.i18n import _
+
+def convert(mlist):
+    for attr in ('msg_header', 'msg_footer', 'digest_header', 'digest_footer',
+                 'autoresponse_postings_text', 'autoresponse_admin_text',
+                 'autoresponse_request_text'):
+        s = getattr(mlist, attr)
+        t = Utils.to_dollar(s)
+        setattr(mlist, attr, t)
+    mlist.use_dollar_strings = 1
+    print _('Saving list')
+    mlist.Save()
+
+
+
+if __name__ == '__main__':
+    print _(__doc__.replace('%', '%%'))
diff --git a/bin/dumpdb b/bin/dumpdb
new file mode 100644
index 00000000..be04385b
--- /dev/null
+++ b/bin/dumpdb
@@ -0,0 +1,134 @@
+#! @PYTHON@
+#
+# 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.
+
+"""Dump the contents of any Mailman `database' file.
+
+Usage: %(PROGRAM)s [options] filename
+
+Options:
+
+    --marshal/-m
+        Assume the file contains a Python marshal, overridding any automatic
+        guessing.
+
+    --pickle/-p
+        Assume the file contains a Python pickle, overridding any automatic
+        guessing.
+
+    --noprint/-n
+        Don't attempt to pretty print the object.  This is useful if there's
+        some problem with the object and you just want to get an unpickled
+        representation.  Useful with `python -i bin/dumpdb <file>'.  In that
+        case, the root of the tree will be left in a global called "msg".
+
+    --help/-h
+        Print this help message and exit
+
+If the filename ends with `.db', then it is assumed that the file contains a
+Python marshal.  If the file ends with `.pck' then it is assumed to contain a
+Python pickle.  In either case, if you want to override the default assumption
+-- or if the file ends in neither suffix -- use the -p or -m flags.
+"""
+
+import sys
+import os
+import getopt
+import pprint
+import cPickle
+
+import paths
+# Import this /after/ paths so that the sys.path is properly hacked
+from email.Generator import Generator
+
+from Mailman.Queue.Switchboard import DumperSwitchboard
+from Mailman.i18n import _
+
+PROGRAM = sys.argv[0]
+COMMASPACE = ', '
+
+
+
+def usage(code, msg=''):
+    if code:
+        fd = sys.stderr
+    else:
+        fd = sys.stdout
+    print >> fd, _(__doc__) % globals()
+    if msg:
+        print >> fd, msg
+    sys.exit(code)
+
+
+
+def main():
+    try:
+        opts, args = getopt.getopt(sys.argv[1:], 'mphn',
+                                   ['marshal', 'pickle', 'help', 'noprint'])
+    except getopt.error, msg:
+        usage(1, msg)
+
+    # Options.
+    # None == guess, 0 == pickle, 1 == marshal
+    filetype = None
+    doprint = 1
+
+    for opt, arg in opts:
+        if opt in ('-h', '--help'):
+            usage(0)
+        elif opt in ('-p', '--pickle'):
+            filetype = 0
+        elif opt in ('-m', '--marshal'):
+            filetype = 1
+        elif opt in ('-n', '--noprint'):
+            doprint = 0
+
+    if len(args) < 1:
+        usage(1, _('No filename given.'))
+    elif len(args) > 1:
+        pargs = COMMASPACE.join(args)
+        usage(1, _('Bad arguments: %(pargs)s'))
+    else:
+        filename = args[0]
+
+    if filetype is None:
+        if filename.endswith('.db'):
+            filetype = 1
+        elif filename.endswith('.pck'):
+            filetype = 0
+        else:
+            usage(1, _('Please specify either -p or -m.'))
+
+    # Handle dbs
+    pp = pprint.PrettyPrinter(indent=4)
+    if filetype == 1:
+        # BAW: this probably doesn't work if there are mixed types of .db
+        # files (i.e. some marshals, some bdbs).
+        d = DumperSwitchboard().read(filename)
+        if doprint:
+            pp.pprint(d)
+        return d
+    else:
+        m = cPickle.load(open(filename))
+        if doprint:
+            pp.pprint(m)
+        return m
+
+
+
+if __name__ == '__main__':
+    msg = main()
diff --git a/bin/find_member b/bin/find_member
new file mode 100755
index 00000000..0656d500
--- /dev/null
+++ b/bin/find_member
@@ -0,0 +1,184 @@
+#! @PYTHON@
+#
+# 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.
+
+"""Find all lists that a member's address is on.
+
+Usage:
+    find_member [options] regex [regex [...]]
+
+Where:
+    --listname=listname
+    -l listname
+        Include only the named list in the search.
+
+    --exclude=listname
+    -x listname
+        Exclude the named list from the search.
+
+    --owners
+    -w
+        Search list owners as well as members.
+
+    --help
+    -h
+        Print this help message and exit.
+
+    regex
+        A Python regular expression to match against.
+
+The interaction between -l and -x is as follows.  If any -l option is given
+then only the named list will be included in the search.  If any -x option is
+given but no -l option is given, then all lists will be search except those
+specifically excluded.
+
+Regular expression syntax is Perl5-like, using the Python re module.  Complete
+specifications are at:
+
+http://www.python.org/doc/current/lib/module-re.html
+
+Address matches are case-insensitive, but case-preserved addresses are
+displayed.
+
+"""
+
+import sys
+import re
+import getopt
+
+import paths
+from Mailman import Utils
+from Mailman import MailList
+from Mailman import Errors
+from Mailman.i18n import _
+
+AS_MEMBER = 0x01
+AS_OWNER = 0x02
+
+
+
+def usage(code, msg=''):
+    if code:
+        fd = sys.stderr
+    else:
+        fd = sys.stdout
+    print >> fd, _(__doc__)
+    if msg:
+        print >> fd, msg
+    sys.exit(code)
+
+
+
+def scanlists(options):
+    cres = []
+    for r in options.regexps:
+        cres.append(re.compile(r, re.IGNORECASE))
+    #
+    # dictionary of {address, (listname, ownerp)}
+    matches = {}
+    for listname in options.listnames:
+        try:
+            mlist = MailList.MailList(listname, lock=0)
+        except Errors.MMListError:
+            print _('No such list: %(listname)s')
+            continue
+        if options.owners:
+            owners = mlist.owner
+        else:
+            owners = []
+        for cre in cres:
+            for member in mlist.getMembers():
+                if cre.search(member):
+                    addr = mlist.getMemberCPAddress(member)
+                    entries = matches.get(addr, {})
+                    aswhat = entries.get(listname, 0)
+                    aswhat |=  AS_MEMBER
+                    entries[listname] = aswhat
+                    matches[addr] = entries
+            for owner in owners:
+                if cre.search(owner):
+                    entries = matches.get(addr, {})
+                    aswhat = entries.get(listname, 0)
+                    aswhat |= AS_OWNER
+                    entries[listname] = aswhat
+                    matches[addr] = entries
+    return matches
+
+
+
+class Options:
+    listnames = Utils.list_names()
+    owners = None
+
+
+def main():
+    try:
+        opts, args = getopt.getopt(sys.argv[1:], 'l:x:wh',
+                                   ['listname=', 'exclude=', 'owners',
+                                    'help'])
+    except getopt.error, msg:
+        usage(1, msg)
+
+    options = Options()
+    loptseen = 0
+    excludes = []
+    for opt, arg in opts:
+        if opt in ('-h', '--help'):
+            usage(0)
+        elif opt in ('-l', '--listname'):
+            if not loptseen:
+                options.listnames = []
+                loptseen = 1
+            options.listnames.append(arg.lower())
+        elif opt in ('-x', '--exclude'):
+            excludes.append(arg.lower())
+        elif opt in ('-w', '--owners'):
+            options.owners = 1
+
+    for ex in excludes:
+        try:
+            options.listnames.remove(ex)
+        except ValueError:
+            pass
+
+    if not args:
+        usage(1, _('Search regular expression required'))
+
+    options.regexps = args
+
+    if not options.listnames:
+        print _('No lists to search')
+        return
+
+    matches = scanlists(options)
+    addrs = matches.keys()
+    addrs.sort()
+    for k in addrs:
+        hits = matches[k]
+        lists = hits.keys()
+        print k, _('found in:')
+        for name in lists:
+            aswhat = hits[name]
+            if aswhat & AS_MEMBER:
+                print '    ', name
+            if aswhat & AS_OWNER:
+                print '    ', name, _('(as owner)')
+
+
+
+if __name__ == '__main__':
+    main()
diff --git a/bin/fix_url.py b/bin/fix_url.py
new file mode 100644
index 00000000..582a0e76
--- /dev/null
+++ b/bin/fix_url.py
@@ -0,0 +1,92 @@
+#! @PYTHON@
+#
+# Copyright (C) 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.
+
+"""Reset a list's web_page_url attribute to the default setting.
+
+This script is intended to be run as a bin/withlist script, i.e.
+
+% bin/withlist -l -r fix_url listname [options]
+
+Options:
+    -u urlhost
+    --urlhost=urlhost
+        Look up urlhost in the virtual host table and set the web_page_url and
+        host_name attributes of the list to the values found.  This
+        essentially moves the list from one virtual domain to another.
+
+        Without this option, the default web_page_url and host_name values are
+        used.
+
+    -v / --verbose
+        Print what the script is doing.
+
+If run standalone, it prints this help text and exits.
+"""
+
+import sys
+import getopt
+
+import paths
+from Mailman import mm_cfg
+from Mailman.i18n import _
+
+
+
+def usage(code, msg=''):
+    print _(__doc__.replace('%', '%%'))
+    if msg:
+        print msg
+    sys.exit(code)
+
+
+
+def fix_url(mlist, *args):
+    try:
+        opts, args = getopt.getopt(args, 'u:v', ['urlhost=', 'verbose'])
+    except getopt.error, msg:
+        usage(1, msg)
+
+    verbose = 0
+    urlhost = mailhost = None
+    for opt, arg in opts:
+        if opt in ('-u', '--urlhost'):
+            urlhost = arg
+        elif opt in ('-v', '--verbose'):
+            verbose = 1
+
+    if urlhost:
+        web_page_url = mm_cfg.DEFAULT_URL_PATTERN % urlhost
+        mailhost = mm_cfg.VIRTUAL_HOSTS.get(urlhost.lower(), urlhost)
+    else:
+        web_page_url = mm_cfg.DEFAULT_URL_PATTERN % mm_cfg.DEFAULT_URL_HOST
+        mailhost = mm_cfg.DEFAULT_EMAIL_HOST
+
+    if verbose:
+        print _('Setting web_page_url to: %(web_page_url)s')
+    mlist.web_page_url = web_page_url
+    if verbose:
+        print _('Setting host_name to: %(mailhost)s')
+    mlist.host_name = mailhost
+    print _('Saving list')
+    mlist.Save()
+    mlist.Unlock()
+
+
+
+if __name__ == '__main__':
+    usage(0)
diff --git a/bin/genaliases b/bin/genaliases
new file mode 100644
index 00000000..289c5bec
--- /dev/null
+++ b/bin/genaliases
@@ -0,0 +1,102 @@
+#! @PYTHON@
+#
+# Copyright (C) 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.
+
+"""Regenerate Postfix's data/aliases and data/aliases.db files from scratch.
+
+Usage:
+
+    genaliases [options]
+
+Options:
+
+    -h/--help
+        Print this message and exit.
+"""
+
+import sys
+import os
+import getopt
+import fcntl
+
+import paths                                      # path hacking
+from Mailman import mm_cfg
+from Mailman import Utils
+from Mailman import MailList
+from Mailman.i18n import _
+
+
+
+def usage(code, msg=''):
+    if code:
+        fd = sys.stderr
+    else:
+        fd = sys.stdout
+    print >> fd, _(__doc__)
+    if msg:
+        print >> fd, msg
+    sys.exit(code)
+
+
+
+def main():
+    try:
+        opts, args = getopt.getopt(sys.argv[1:], 'h', ['help'])
+    except getopt.error, msg:
+        usage(1, msg)
+
+    for opt, arg in opts:
+        if opt in ('-h', '--help'):
+            usage(0)
+
+    if args:
+        usage(1)
+
+    # Open up the MTA specific module
+    modulename = 'Mailman.MTA.' + mm_cfg.MTA
+    __import__(modulename)
+    MTA = sys.modules[modulename]
+
+    # Open the text file and Berkeley DB files, truncating any data already
+    # there.  We need to acquire a lock so nobody tries to update the files
+    # while we're doing it.
+    lock = MTA.makelock()
+    lock.lock()
+    # Group lists by virtual hostname
+    mlists = {}
+    for listname in Utils.list_names():
+        mlist = MailList.MailList(listname, lock=0)
+        mlists.setdefault(mlist.host_name, []).append(mlist)
+    # Make sure the files are created rw-rw-xxx; it should be okay to be world
+    # readable.
+    omask = os.umask(002)
+    try:
+        MTA.clear()
+        if not mlists:
+            MTA.create(None, nolock=1)
+        else:
+            for hostname, vlists in mlists.items():
+                for mlist in vlists:
+                    MTA.create(mlist, nolock=1)
+    finally:
+        os.umask(omask)
+        lock.unlock(unconditionally=1)
+
+
+
+if __name__ == '__main__':
+    main()
diff --git a/bin/inject b/bin/inject
new file mode 100644
index 00000000..50deba6a
--- /dev/null
+++ b/bin/inject
@@ -0,0 +1,107 @@
+#! @PYTHON@
+#
+# Copyright (C) 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.
+
+"""Inject a message from a file into Mailman's incoming queue.
+
+Usage: inject [options] [filename]
+
+Options:
+
+    -h / --help
+        Print this text and exit.
+
+    -l listname
+    --listname=listname
+        The name of the list to inject this message to.  Required.
+
+    -q queuename
+    --queue=queuename
+        The name of the queue to inject the message to.  The queuename must be
+        one of the directories inside the qfiles directory.  If omitted, the
+        incoming queue is used.
+
+filename is the name of the plaintext message file to inject.  If omitted,
+standard input is used.
+"""
+
+import sys
+import os
+import getopt
+
+import paths
+from Mailman import mm_cfg
+from Mailman import Utils
+from Mailman import Post
+from Mailman.i18n import _
+
+
+
+def usage(code, msg=''):
+    if code:
+        fd = sys.stderr
+    else:
+        fd = sys.stdout
+    print >> fd, _(__doc__)
+    if msg:
+        print >> fd, msg
+    sys.exit(code)
+
+
+
+def main():
+    try:
+        opts, args = getopt.getopt(
+            sys.argv[1:], 'hl:q:L',
+            ['help', 'listname=', 'queue=', 'showqnames'])
+    except getopt.error, msg:
+        usage(1, msg)
+
+    qdir = mm_cfg.INQUEUE_DIR
+    listname = None
+
+    for opt, arg in opts:
+        if opt in ('-h', '--help'):
+            usage(0)
+        elif opt in ('-q', '--queue'):
+            qdir = os.path.join(mm_cfg.QUEUE_DIR, arg)
+            if not os.path.isdir(qdir):
+                usage(1, _('Bad queue directory: %(qdir)s'))
+        elif opt in ('-l', '--listname'):
+            listname = arg
+
+    if listname is None:
+        usage(1, _('A list name is required'))
+    elif not Utils.list_exists(listname):
+        usage(1, _('No such list: %(listname)s'))
+              
+    if len(args) == 0:
+        # Use standard input
+        msgtext = sys.stdin.read()
+    elif len(args) == 1:
+        fp = open(args[0])
+        msgtext = fp.read()
+        fp.close()
+    else:
+        usage(1)
+
+    Post.inject(listname, msgtext, qdir=qdir)
+
+
+
+if __name__ == '__main__':
+    main()
diff --git a/bin/list_admins b/bin/list_admins
new file mode 100644
index 00000000..0c4e4ffe
--- /dev/null
+++ b/bin/list_admins
@@ -0,0 +1,101 @@
+#! @PYTHON@
+#
+# Copyright (C) 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.
+
+"""List all the owners of a mailing list.
+
+Usage: %(program)s [options] listname ...
+
+Where:
+
+    --all-vhost=vhost
+    -v=vhost
+        List the owners of all the mailing lists for the given virtual host.
+
+    --all
+    -a
+        List the owners of all the mailing lists on this system.
+
+    --help
+    -h
+        Print this help message and exit.
+
+`listname' is the name of the mailing list to print the owners of.  You can
+have more than one named list on the command line.
+"""
+
+import sys
+import getopt
+
+import paths
+from Mailman import MailList, Utils
+from Mailman import Errors
+from Mailman.i18n import _
+
+COMMASPACE = ', '
+
+program = sys.argv[0]
+
+
+
+def usage(code, msg=''):
+    if code:
+        fd = sys.stderr
+    else:
+        fd = sys.stdout
+    print >> fd, _(__doc__)
+    if msg:
+        print >> fd, msg
+    sys.exit(code)
+
+
+
+def main():
+    try:
+        opts, args = getopt.getopt(sys.argv[1:], 'hv:a',
+                                   ['help', 'all-vhost=', 'all'])
+    except getopt.error, msg:
+        usage(1, msg)
+
+    listnames = args
+    vhost = None
+    for opt, arg in opts:
+        if opt in ('-h', '--help'):
+            usage(0)
+        elif opt in ('-a', '--all'):
+            listnames = Utils.list_names()
+        elif opt in ('-v', '--all-vhost'):
+            listnames = Utils.list_names()
+            vhost = arg
+
+    for listname in listnames:
+       try:
+           mlist = MailList.MailList(listname, lock=0)
+       except Errors.MMListError, e:
+           print _('No such list: %(listname)s')
+           continue
+
+       if vhost and vhost <> mlist.host_name:
+           continue
+
+       owners = COMMASPACE.join(mlist.owner)
+       print _('List: %(listname)s, \tOwners: %(owners)s')
+
+
+
+if __name__ == '__main__':
+    main()
diff --git a/bin/list_lists b/bin/list_lists
new file mode 100644
index 00000000..4dd6b55c
--- /dev/null
+++ b/bin/list_lists
@@ -0,0 +1,122 @@
+#! @PYTHON@
+#
+# 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.
+
+"""List all mailing lists.
+
+Usage: %(program)s [options]
+
+Where:
+
+    -a / --advertised
+        List only those mailing lists that are publically advertised
+
+    --virtual-host-overview=domain
+    -V domain
+        List only those mailing lists that are homed to the given virtual
+        domain.  This only works if the VIRTUAL_HOST_OVERVIEW variable is
+        set.
+
+    -b / --bare
+        Displays only the list name, with no description.
+
+    -h / --help
+        Print this text and exit.
+
+"""
+
+import sys
+import getopt
+import paths
+
+from Mailman import mm_cfg
+from Mailman import MailList
+from Mailman import Utils
+from Mailman import Errors
+from Mailman.i18n import _
+
+program = sys.argv[0]
+
+def usage(code, msg=''):
+    if code:
+        fd = sys.stderr
+    else:
+        fd = sys.stdout
+    print >> fd, _(__doc__)
+    if msg:
+        print >> fd, msg
+    sys.exit(code)
+
+
+
+def main():
+    try:
+        opts, args = getopt.getopt(sys.argv[1:], 'abV:h',
+                                   ['advertised', 'bare',
+                                    'virtual-host-overview=',
+                                    'help'])
+    except getopt.error, msg:
+        usage(1, msg)
+
+    advertised = 0
+    vhost = None
+    bare = 0
+    for opt, arg in opts:
+        if opt in ('-h', '--help'):
+            usage(0)
+        elif opt in ('-a', '--advertised'):
+            advertised = 1
+        elif opt in ('-V', '--virtual-host-overview'):
+            vhost = arg
+        elif opt in ('-b', '--bare'):
+            bare = 1
+
+    names = Utils.list_names()
+    names.sort()
+
+    mlists = []
+    longest = 0
+    for n in names:
+        mlist = MailList.MailList(n, lock=0)
+        if advertised and not mlist.advertised:
+            continue
+        if vhost and mm_cfg.VIRTUAL_HOST_OVERVIEW and \
+               vhost.find(mlist.web_page_url) == -1 and \
+               mlist.web_page_url.find(vhost) == -1:
+            continue
+        mlists.append(mlist)
+        longest = max(len(mlist.real_name), longest)
+
+    if not mlists and not bare:
+        print _('No matching mailing lists found')
+        return
+
+    if not bare:
+        print len(mlists), _('matching mailing lists found:')
+
+    format = '%%%ds - %%.%ds' % (longest, 77 - longest)
+    for mlist in mlists:
+        if bare:
+            print mlist.internal_name()
+        else:
+            description = mlist.description or _('[no description available]')
+            print '   ', format % (mlist.real_name, description)
+
+
+
+if __name__ == '__main__':
+    main()
diff --git a/bin/list_members b/bin/list_members
new file mode 100755
index 00000000..3ad10f51
--- /dev/null
+++ b/bin/list_members
@@ -0,0 +1,232 @@
+#! @PYTHON@
+#
+# 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.
+
+"""List all the members of a mailing list.
+
+Usage: %(PROGRAM)s [options] listname
+
+Where:
+
+    --output file
+    -o file
+        Write output to specified file instead of standard out.
+
+    --regular / -r
+        Print just the regular (non-digest) members.
+
+    --digest[=kind] / -d [kind]
+        Print just the digest members.  Optional argument can be "mime" or
+        "plain" which prints just the digest members receiving that kind of
+        digest.
+
+    --nomail[=why] / -n [why]
+        Print the members that have delivery disabled.  Optional argument can
+        be "byadmin", "byuser", "bybounce", or "unknown" which prints just the
+        users who have delivery disabled for that reason.  It can also be
+        "enabled" which prints just those member for whom delivery is
+        enabled.
+
+    --fullnames / -f
+        Include the full names in the output.
+
+    --preserve
+    -p
+        Output member addresses case preserved the way they were added to the
+        list.  Otherwise, addresses are printed in all lowercase.
+
+    --help
+    -h
+        Print this help message and exit.
+
+    listname is the name of the mailing list to use.
+
+Note that if neither -r or -d is supplied, both regular members are printed
+first, followed by digest members, but no indication is given as to address
+status.
+"""
+
+import sys
+
+import paths
+from Mailman import mm_cfg
+from Mailman import MailList
+from Mailman import Errors
+from Mailman import MemberAdaptor
+from Mailman.i18n import _
+
+from email.Utils import formataddr
+
+PROGRAM = sys.argv[0]
+WHYCHOICES = {'enabled' : MemberAdaptor.ENABLED,
+              'unknown' : MemberAdaptor.UNKNOWN,
+              'byuser'  : MemberAdaptor.BYUSER,
+              'byadmin' : MemberAdaptor.BYADMIN,
+              'bybounce': MemberAdaptor.BYBOUNCE,
+              }
+
+
+def usage(code, msg=''):
+    if code:
+        fd = sys.stderr
+    else:
+        fd = sys.stdout
+    print >> fd, _(__doc__)
+    if msg:
+        print >> fd, msg
+    sys.exit(code)
+
+
+
+def whymatches(mlist, addr, why):
+    # Return true if the `why' matches the reason the address is enabled, or
+    # in the case of why is None, that they are disabled for any reason
+    # (i.e. not enabled).
+    status = mlist.getDeliveryStatus(addr)
+    if why is None:
+        return status <> MemberAdaptor.ENABLED
+    return status == WHYCHOICES[why]
+
+
+
+def main():
+    # Because of the optional arguments, we can't use getopt. :(
+    outfile = None
+    regular = None
+    digest = None
+    preserve = None
+    nomail = None
+    why = None
+    kind = None
+    fullnames = 0
+
+    # Throw away the first (program) argument
+    args = sys.argv[1:]
+    if not args:
+        usage(0)
+
+    while 1:
+        try:
+            opt = args.pop(0)
+        except IndexError:
+            usage(1)
+        if opt in ('-h', '--help'):
+            usage(0)
+        elif opt in ('-f', '--fullnames'):
+            fullnames = 1
+        elif opt in ('-p', '--preserve'):
+            preserve = 1
+        elif opt in ('-r', '--regular'):
+            regular = 1
+        elif opt in ('-o', '--output'):
+            try:
+                outfile = args.pop(0)
+            except IndexError:
+                usage(1)
+        elif opt == '-n':
+            nomail = 1
+            if args and args[0] in WHYCHOICES.keys():
+                why = args.pop(0)
+        elif opt.startswith('--nomail'):
+            nomail = 1
+            i = opt.find('=')
+            if i >= 0:
+                why = opt[i+1:]
+                if why not in WHYCHOICES.keys():
+                    usage(1, _('Bad --nomail option: %(why)s'))
+        elif opt == '-d':
+            digest = 1
+            if args and args[0] in ('mime', 'plain'):
+                kind = args.pop(0)
+        elif opt.startswith('--digest'):
+            digest = 1
+            i = opt.find('=')
+            if i >= 0:
+                kind = opt[i+1:]
+                if kind not in ('mime', 'plain'):
+                    usage(1, _('Bad --digest option: %(kind)s'))
+        else:
+            # No more options left, push the last one back on the list
+            args.insert(0, opt)
+            break
+
+    if len(args) <> 1:
+        usage(1)
+
+    listname = args[0].lower().strip()
+
+    if regular is None and digest is None:
+        regular = digest = 1
+
+    if outfile:
+        try:
+            fp = open(outfile, 'w')
+        except IOError:
+            print >> sys.stderr, _('Could not open file for writing:'), outfile
+            sys.exit(1)
+    else:
+        fp = sys.stdout
+
+    try:
+        mlist = MailList.MailList(listname, lock=0)
+    except Errors.MMListError, e:
+        print >> sys.stderr, _('No such list: %(listname)s')
+        sys.exit(1)
+
+    # Get the lowercased member addresses
+    rmembers = mlist.getRegularMemberKeys()
+    dmembers = mlist.getDigestMemberKeys()
+
+    if preserve:
+        # Convert to the case preserved addresses
+        rmembers = mlist.getMemberCPAddresses(rmembers)
+        dmembers = mlist.getMemberCPAddresses(dmembers)
+
+    if regular:
+        rmembers.sort()
+        for addr in rmembers:
+            name = fullnames and mlist.getMemberName(addr)
+            # Filter out nomails
+            if nomail and not whymatches(mlist, addr, why):
+                continue
+            enc = sys.getdefaultencoding()
+            s = formataddr((name, addr)).encode(enc, 'replace')
+            print >> fp, s
+    if digest:
+        dmembers.sort()
+        for addr in dmembers:
+            name = fullnames and mlist.getMemberName(addr)
+            # Filter out nomails
+            if nomail and not whymatches(mlist, addr, why):
+                continue
+            # Filter out digest kinds
+            if mlist.getMemberOption(addr, mm_cfg.DisableMime):
+                # They're getting plain text digests
+                if kind == 'mime':
+                    continue
+            else:
+                # They're getting MIME digests
+                if kind == 'plain':
+                    continue
+            enc = sys.getdefaultencoding()
+            s = formataddr((name, addr)).encode(enc, 'replace')
+            print >> fp, s
+
+
+
+if __name__ == '__main__':
+    main()
diff --git a/bin/list_owners b/bin/list_owners
new file mode 100644
index 00000000..baacf27a
--- /dev/null
+++ b/bin/list_owners
@@ -0,0 +1,120 @@
+#! @PYTHON@
+#
+# Copyright (C) 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.
+
+"""List the owners of a mailing list, or all mailing lists.
+
+Usage: %(PROGRAM)s [options] [listname ...]
+Options:
+
+    -w / --with-listnames
+        Group the owners by list names and include the list names in the
+        output.  Otherwise, the owners will be sorted and uniquified based on
+        the email address.
+
+    -m / --moderators
+        Include the list moderators in the output.
+
+    -h / --help
+        Print this help message and exit.
+
+    listname
+        Print the owners of the specified lists.  More than one can appear
+        after the options.  If there are no listnames provided, the owners of
+        all the lists will be displayed.
+"""
+
+import sys
+import getopt
+
+import paths
+from Mailman import Utils
+from Mailman.MailList import MailList
+from Mailman.i18n import _
+
+PROGRAM = sys.argv[0]
+
+try:
+    True, False
+except NameError:
+    True = 1
+    False = 0
+
+
+
+def usage(code, msg=''):
+    if code:
+        fd = sys.stderr
+    else:
+        fd = sys.stdout
+    print >> fd, _(__doc__)
+    if msg:
+        print >> fd, msg
+    sys.exit(code)
+
+
+
+def main():
+    try:
+        opts, args = getopt.getopt(sys.argv[1:], 'wmh',
+                                   ['with-listnames', 'moderators', 'help'])
+    except getopt.error, msg:
+        usage(1, msg)
+
+    withnames = moderators = False
+    for opt, arg in opts:
+        if opt in ('-h', '--help'):
+            usage(0)
+        elif opt in ('-m', '--moderators'):
+            moderators = True
+        elif opt in ('-w', '--with-listnames'):
+            withnames = True
+
+    listnames = args or Utils.list_names()
+    bylist = {}
+
+    for listname in listnames:
+        mlist = MailList(listname, lock=0)
+        addrs = mlist.owner[:]
+        if moderators:
+            addrs.extend(mlist.moderator)
+        bylist[listname] = addrs
+
+    if withnames:
+        for listname in listnames:
+            unique = {}
+            for addr in bylist[listname]:
+                unique[addr] = 1
+            keys = unique.keys()
+            keys.sort()
+            print listname
+            for k in keys:
+                print '\t', k
+    else:
+        unique = {}
+        for listname in listnames:
+            for addr in bylist[listname]:
+                unique[addr] = 1
+        keys = unique.keys()
+        keys.sort()
+        for k in keys:
+            print k
+
+
+
+if __name__ == '__main__':
+    main()
diff --git a/bin/mailmanctl b/bin/mailmanctl
new file mode 100644
index 00000000..0292e1f3
--- /dev/null
+++ b/bin/mailmanctl
@@ -0,0 +1,524 @@
+#! @PYTHON@
+
+# Copyright (C) 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.
+
+"""Primary start-up and shutdown script for Mailman's qrunner daemon.
+
+This script starts, stops, and restarts the main Mailman queue runners, making
+sure that the various long-running qrunners are still alive and kicking.  It
+does this by forking and exec'ing the qrunners and waiting on their pids.
+When it detects a subprocess has exited, it may restart it.
+
+The qrunners respond to SIGINT, SIGTERM, and SIGHUP.  SIGINT and SIGTERM both
+cause the qrunners to exit cleanly, but the master will only restart qrunners
+that have exited due to a SIGINT.  SIGHUP causes the master and the qrunners
+to close their log files, and reopen then upon the next printed message.
+
+The master also responds to SIGINT, SIGTERM, and SIGHUP, which it simply
+passes on to the qrunners (note that the master will close and reopen its own
+log files on receipt of a SIGHUP).  The master also leaves its own process id
+in the file data/master-qrunner.pid but you normally don't need to use this
+pid directly.  The `start', `stop', `restart', and `reopen' commands handle
+everything for you.
+
+Usage: %(PROGRAM)s [options] [ start | stop | restart | reopen ]
+
+Options:
+
+    -n/--no-restart
+        Don't restart the qrunners when they exit because of an error or a
+        SIGINT.  They are never restarted if they exit in response to a
+        SIGTERM.  Use this only for debugging.  Only useful if the `start'
+        command is given.
+
+    -u/--run-as-user
+        Normally, this script will refuse to run if the user id and group id
+        are not set to the `mailman' user and group (as defined when you
+        configured Mailman).  If run as root, this script will change to this
+        user and group before the check is made.
+
+        This can be inconvenient for testing and debugging purposes, so the -u
+        flag means that the step that sets and checks the uid/gid is skipped,
+        and the program is run as the current user and group.  This flag is
+        not recommended for normal production environments.
+
+        Note though, that if you run with -u and are not in the mailman group,
+        you may have permission problems, such as begin unable to delete a
+        list's archives through the web.  Tough luck!
+
+    -s/--stale-lock-cleanup
+        If mailmanctl finds an existing master lock, it will normally exit
+        with an error message.  With this option, mailmanctl will perform an
+        extra level of checking.  If a process matching the host/pid described
+        in the lock file is running, mailmanctl will still exit, but if no
+        matching process is found, mailmanctl will remove the apparently stale
+        lock and make another attempt to claim the master lock.
+
+    -q/--quiet
+        Don't print status messages.  Error messages are still printed to
+        standard error.
+
+    -h/--help
+        Print this message and exit.
+
+Commands:
+
+    start   - Start the master daemon and all qrunners.  Prints a message and
+              exits if the master daemon is already running.
+
+    stop    - Stops the master daemon and all qrunners.  After stopping, no
+              more messages will be processed.
+
+    restart - Restarts the qrunners, but not the master process.  Use this
+              whenever you upgrade or update Mailman so that the qrunners will
+              use the newly installed code.
+
+    reopen  - This will close all log files, causing them to be re-opened the
+              next time a message is written to them
+"""
+
+import sys
+import os
+import time
+import getopt
+import signal
+import errno
+import pwd
+import grp
+import socket
+
+import paths
+from Mailman import mm_cfg
+from Mailman import Utils
+from Mailman import LockFile
+from Mailman.i18n import _
+from Mailman.Logging.Syslog import syslog
+from Mailman.Logging.Utils import LogStdErr
+
+PROGRAM = sys.argv[0]
+COMMASPACE = ', '
+DOT = '.'
+
+# Locking contantsa
+LOCKFILE = os.path.join(mm_cfg.LOCK_DIR, 'master-qrunner')
+# Since we wake up once per day and refresh the lock, the LOCK_LIFETIME
+# needn't be (much) longer than SNOOZE.  We pad it 6 hours just to be safe.
+LOCK_LIFETIME = mm_cfg.days(1) + mm_cfg.hours(6)
+SNOOZE = mm_cfg.days(1)
+MAX_RESTARTS = 10
+
+LogStdErr('error', 'mailmanctl', manual_reprime=0)
+
+
+
+def usage(code, msg=''):
+    if code:
+        fd = sys.stderr
+    else:
+        fd = sys.stdout
+    print >> fd, _(__doc__)
+    if msg:
+        print >> fd, msg
+    sys.exit(code)
+
+
+
+def kill_watcher(sig):
+    try:
+        fp = open(mm_cfg.PIDFILE)
+        pidstr = fp.read()
+        fp.close()
+        pid = int(pidstr.strip())
+    except (IOError, ValueError), e:
+        # For i18n convenience
+        pidfile = mm_cfg.PIDFILE
+        print >> sys.stderr, _('PID unreadable in: %(pidfile)s')
+        print >> sys.stderr, e
+        print >> sys.stderr, _('Is qrunner even running?')
+        return
+    try:
+        os.kill(pid, sig)
+    except OSError, e:
+        if e.errno <> errno.ESRCH: raise
+        print >> sys.stderr, _('No child with pid: %(pid)s')
+        print >> sys.stderr, e
+        print >> sys.stderr, _('Stale pid file removed.')
+        os.unlink(mm_cfg.PIDFILE)
+
+
+
+def get_lock_data():
+    # Return the hostname, pid, and tempfile
+    fp = open(LOCKFILE)
+    filename = os.path.split(fp.read().strip())[1]
+    fp.close()
+    parts = filename.split('.')
+    hostname = DOT.join(parts[1:-1])
+    pid = int(parts[-1])
+    return hostname, int(pid), filename
+
+
+def qrunner_state():
+    # 1 if proc exists on host (but is it qrunner? ;)
+    # 0 if host matches but no proc
+    # hostname if hostname doesn't match
+    hostname, pid, tempfile = get_lock_data()
+    if hostname <> socket.gethostname():
+        return hostname
+    # Find out if the process exists by calling kill with a signal 0.
+    try:
+        os.kill(pid, 0)
+    except OSError, e:
+        if e.errno <> errno.ESRCH: raise
+        return 0
+    return 1
+
+
+def acquire_lock_1(force):
+    # Be sure we can acquire the master qrunner lock.  If not, it means some
+    # other master qrunner daemon is already going.
+    lock = LockFile.LockFile(LOCKFILE, LOCK_LIFETIME)
+    try:
+        lock.lock(0.1)
+        return lock
+    except LockFile.TimeOutError:
+        if not force:
+            raise
+        # Force removal of lock first
+        lock._disown()
+        hostname, pid, tempfile = get_lock_data()
+        os.unlink(LOCKFILE)
+        os.unlink(os.path.join(mm_cfg.LOCK_DIR, tempfile))
+        return acquire_lock_1(force=0)
+
+
+def acquire_lock(force):
+    try:
+        lock = acquire_lock_1(force)
+        return lock
+    except LockFile.TimeOutError:
+        status = qrunner_state()
+        if status == 1:
+            # host matches and proc exists
+            print >> sys.stderr, _("""\
+The master qrunner lock could not be acquired because it appears as if another
+master qrunner is already running.
+""")
+        elif status == 0:
+            # host matches but no proc
+            print >> sys.stderr, _("""\
+The master qrunner lock could not be acquired.  It appears as though there is
+a stale master qrunner lock.  Try re-running mailmanctl with the -s flag.
+""")
+        else:
+            # host doesn't even match
+            print >> sys.stderr, _("""\
+The master qrunner lock could not be acquired, because it appears as if some
+process on some other host may have acquired it.  We can't test for stale
+locks across host boundaries, so you'll have to do this manually.  Or, if you
+know the lock is stale, re-run mailmanctl with the -s flag.
+
+Lock file: %(LOCKFILE)s
+Lock host: %(status)s
+
+Exiting.""")
+
+
+
+def start_runner(qrname, slice, count):
+    pid = os.fork()
+    if pid:
+        # parent
+        return pid
+    # child
+    #
+    # Craft the command line arguments for the exec() call.
+    rswitch = '--runner=%s:%d:%d' % (qrname, slice, count)
+    # BAW: should argv[0] be `python'?
+    exe = os.path.join(mm_cfg.BIN_DIR, 'qrunner')
+    os.execl(mm_cfg.PYTHON, 'qrunner', exe, rswitch, '-s')
+    # Should never get here
+    raise RuntimeError, 'os.execl() failed'
+
+
+def start_all_runners():
+    kids = {}
+    for qrname, count in mm_cfg.QRUNNERS:
+        for slice in range(count):
+            # queue runner name, slice, numslices, restart count
+            info = (qrname, slice, count, 0)
+            pid = start_runner(qrname, slice, count)
+            kids[pid] = info
+    return kids
+
+
+
+def check_privs():
+    # If we're running as root (uid == 0), coerce the uid and gid to that
+    # which Mailman was configured for, and refuse to run if we didn't coerce
+    # the uid/gid.
+    gid = grp.getgrnam(mm_cfg.MAILMAN_GROUP)[2]
+    uid = pwd.getpwnam(mm_cfg.MAILMAN_USER)[2]
+    myuid = os.getuid()
+    if myuid == 0:
+        os.setgid(gid)
+        os.setuid(uid)
+    elif myuid <> uid:
+        name = mm_cfg.MAILMAN_USER
+        usage(1, _(
+            'Run this program as root or as the %(name)s user, or use -u.'))
+
+
+
+def main():
+    global quiet
+    try:
+        opts, args = getopt.getopt(sys.argv[1:], 'hnusq',
+                                   ['help', 'no-start', 'run-as-user',
+                                    'stale-lock-cleanup', 'quiet'])
+    except getopt.error, msg:
+        usage(1, msg)
+
+    restart = 1
+    checkprivs = 1
+    force = 0
+    quiet = 0
+    for opt, arg in opts:
+        if opt in ('-h', '--help'):
+            usage(0)
+        elif opt in ('-n', '--no-restart'):
+            restart = 0
+        elif opt in ('-u', '--run-as-user'):
+            checkprivs = 0
+        elif opt in ('-s', '--stale-lock-cleanup'):
+            force = 1
+        elif opt in ('-q', '--quiet'):
+            quiet = 1
+
+    if len(args) < 1:
+        usage(1, _('No command given.'))
+    elif len(args) > 1:
+        command = COMMASPACE.join(args)
+        usage(1, _('Bad command: %(command)s'))
+
+    if checkprivs:
+        check_privs()
+    else:
+        print _('Warning!  You may encounter permission problems.')
+
+    # Handle the commands
+    command = args[0].lower()
+    if command == 'stop':
+        # Sent the master qrunner process a SIGINT, which is equivalent to
+        # giving cron/qrunner a ctrl-c or KeyboardInterrupt.  This will
+        # effectively shut everything down.
+        if not quiet:
+            print _("Shutting down Mailman's master qrunner")
+        kill_watcher(signal.SIGTERM)
+    elif command == 'restart':
+        # Sent the master qrunner process a SIGHUP.  This will cause the
+        # master qrunner to kill and restart all the worker qrunners, and to
+        # close and re-open its log files.
+        if not quiet:
+            print _("Restarting Mailman's master qrunner")
+        kill_watcher(signal.SIGINT)
+    elif command == 'reopen':
+        if not quiet:
+            print _('Re-opening all log files')
+        kill_watcher(signal.SIGHUP)
+    elif command == 'start':
+        # Here's the scoop on the processes we're about to create.  We'll need
+        # one for each qrunner, and one for a master child process watcher /
+        # lock refresher process.
+        #
+        # The child watcher process simply waits on the pids of the children
+        # qrunners.  Unless explicitly disabled by a mailmanctl switch (or the
+        # children are killed with SIGTERM instead of SIGINT), the watcher
+        # will automatically restart any child process that exits.  This
+        # allows us to be more robust, and also to implement restart by simply
+        # SIGINT'ing the qrunner children, and letting the watcher restart
+        # them.
+        #
+        # Under normal operation, we have a child per queue.  This lets us get
+        # the most out of the available resources, since a qrunner with no
+        # files in its queue directory is pretty cheap, but having a separate
+        # runner process per queue allows for a very responsive system.  Some
+        # people want a more traditional (i.e. MM2.0.x) cron-invoked qrunner.
+        # No problem, but using mailmanctl isn't the answer.  So while
+        # mailmanctl hard codes some things, others, such as the number of
+        # qrunners per queue, is configurable in mm_cfg.py.
+        #
+        # First, acquire the master mailmanctl lock
+        lock = acquire_lock(force)
+        if not lock:
+            return
+        # Daemon process startup according to Stevens, Advanced Programming in
+        # the UNIX Environment, Chapter 13.
+        pid = os.fork()
+        if pid:
+            # parent
+            if not quiet:
+                print _("Starting Mailman's master qrunner.")
+            # Give up the lock "ownership".  This just means the foreground
+            # process won't close/unlock the lock when it finalizes this lock
+            # instance.  We'll let the mater watcher subproc own the lock.
+            lock._transfer_to(pid)
+            return
+        # child
+        lock._take_possession()
+        # First, save our pid in a file for "mailmanctl stop" rendezvous.  We
+        # want the perms on the .pid file to be rw-rw----
+        omask = os.umask(6)
+        try:
+            fp = open(mm_cfg.PIDFILE, 'w')
+            print >> fp, os.getpid()
+            fp.close()
+        finally:
+            os.umask(omask)
+        # Create a new session and become the session leader, but since we
+        # won't be opening any terminal devices, don't do the ultra-paranoid
+        # suggestion of doing a second fork after the setsid() call.
+        os.setsid()
+        # Instead of cd'ing to root, cd to the Mailman installation home
+        os.chdir(mm_cfg.PREFIX)
+        # Clear our file mode creation umask
+        os.umask(0)
+        # I don't think we have any unneeded file descriptors.
+        #
+        # Now start all the qrunners.  This returns a dictionary where the
+        # keys are qrunner pids and the values are tuples of the following
+        # form: (qrname, slice, count).  This does its own fork and exec, and
+        # sets up its own signal handlers.
+        kids = start_all_runners()
+        # Set up a SIGALRM handler to refresh the lock once per day.  The lock
+        # lifetime is 1day+6hours so this should be plenty.
+        def sigalrm_handler(signum, frame, lock=lock):
+            lock.refresh()
+            signal.alarm(mm_cfg.days(1))
+        signal.signal(signal.SIGALRM, sigalrm_handler)
+        signal.alarm(mm_cfg.days(1))
+        # Set up a SIGHUP handler so that if we get one, we'll pass it along
+        # to all the qrunner children.  This will tell them to close and
+        # reopen their log files
+        def sighup_handler(signum, frame, kids=kids):
+            # Closing our syslog will cause it to be re-opened at the next log
+            # print output.
+            syslog.close()
+            for pid in kids.keys():
+                os.kill(pid, signal.SIGHUP)
+            # And just to tweak things...
+            syslog('qrunner',
+                   'Master watcher caught SIGHUP.  Re-opening log files.')
+        signal.signal(signal.SIGHUP, sighup_handler)
+        # We also need to install a SIGTERM handler because that's what init
+        # will kill this process with when changing run levels.
+        def sigterm_handler(signum, frame, kids=kids):
+            for pid in kids.keys():
+                try:
+                    os.kill(pid, signal.SIGTERM)
+                except OSError, e:
+                    if e.errno <> errno.ESRCH: raise
+            syslog('qrunner', 'Master watcher caught SIGTERM.  Exiting.')
+        signal.signal(signal.SIGTERM, sigterm_handler)
+        # Finally, we need a SIGINT handler which will cause the sub-qrunners
+        # to exit, but the master will restart SIGINT'd sub-processes unless
+        # the -n flag was given.
+        def sigint_handler(signum, frame, kids=kids):
+            for pid in kids.keys():
+                os.kill(pid, signal.SIGINT)
+            syslog('qrunner', 'Master watcher caught SIGINT.  Restarting.')
+        signal.signal(signal.SIGINT, sigint_handler)
+        # Now we're ready to simply do our wait/restart loop.  This is the
+        # master qrunner watcher.
+        try:
+            while 1:
+                try:
+                    pid, status = os.wait()
+                except OSError, e:
+                    # No children?  We're done
+                    if e.errno == errno.ECHILD:
+                        break
+                    # If the system call got interrupted, just restart it.
+                    elif e.errno <> errno.EINTR:
+                        raise
+                    continue
+                killsig = exitstatus = None
+                if os.WIFSIGNALED(status):
+                    killsig = os.WTERMSIG(status)
+                if os.WIFEXITED(status):
+                    exitstatus = os.WEXITSTATUS(status)
+                # We'll restart the process unless we were given the
+                # "no-restart" switch, or if the process was SIGTERM'd or
+                # exitted with a SIGTERM exit status.  This lets us better
+                # handle runaway restarts (say, if the subproc had a syntax
+                # error!)
+                restarting = ''
+                if restart:
+                    if (exitstatus == None and killsig <> signal.SIGTERM) or \
+                       (killsig == None and exitstatus <> signal.SIGTERM):
+                        # Then
+                        restarting = '[restarting]'
+                qrname, slice, count, restarts = kids[pid]
+                del kids[pid]
+                syslog('qrunner', """\
+Master qrunner detected subprocess exit
+(pid: %d, sig: %s, sts: %s, class: %s, slice: %d/%d) %s""",
+                       pid, killsig, exitstatus, qrname,
+                       slice+1, count, restarting)
+                # See if we've reached the maximum number of allowable restarts
+                if exitstatus <> signal.SIGINT:
+                    restarts += 1
+                if restarts > MAX_RESTARTS:
+                    syslog('qrunner', """\
+Qrunner %s reached maximum restart limit of %d, not restarting.""",
+                           qrname, MAX_RESTARTS)
+                    restarting = ''
+                # Now perhaps restart the process unless it exited with a
+                # SIGTERM or we aren't restarting.
+                if restarting:
+                    newpid = start_runner(qrname, slice, count)
+                    kids[newpid] = (qrname, slice, count, restarts)
+        finally:
+            # Should we leave the main loop for any reason, we want to be sure
+            # all of our children are exited cleanly.  Send SIGTERMs to all
+            # the child processes and wait for them all to exit.
+            for pid in kids.keys():
+                try:
+                    os.kill(pid, signal.SIGTERM)
+                except OSError, e:
+                    if e.errno == errno.ESRCH:
+                        # The child has already exited
+                        syslog('qrunner', 'ESRCH on pid: %d', pid)
+                        del kids[pid]
+            # Wait for all the children to go away
+            while 1:
+                try:
+                    pid, status = os.wait()
+                except OSError, e:
+                    if e.errno == errno.ECHILD:
+                        break
+                    elif e.errno <> errno.EINTR:
+                        raise
+                    continue
+        # Finally, give up the lock
+        lock.unlock(unconditionally=1)
+        os._exit(0)
+
+
+
+if __name__ == '__main__':
+    main()
diff --git a/bin/mmsitepass b/bin/mmsitepass
new file mode 100755
index 00000000..8ae8bc72
--- /dev/null
+++ b/bin/mmsitepass
@@ -0,0 +1,105 @@
+#! @PYTHON@
+#
+# 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.
+
+"""Set the site password, prompting from the terminal.
+
+The site password can be used in most if not all places that the list
+administrator's password can be used, which in turn can be used in most places
+that a list users password can be used.
+
+Usage: %(PROGRAM)s [options] [password]
+
+Options:
+
+    -c/--listcreator
+        Set the list creator password instead of the site password.  The list
+        creator is authorized to create and remove lists, but does not have
+        the total power of the site administrator.
+
+    -h/--help
+        Print this help message and exit.
+
+If password is not given on the command line, it will be prompted for.
+"""
+
+import sys
+import getpass
+import getopt
+
+import paths
+from Mailman import Utils
+from Mailman.i18n import _
+
+PROGRAM = sys.argv[0]
+
+
+
+def usage(code, msg=''):
+    if code:
+        fd = sys.stderr
+    else:
+        fd = sys.stdout
+    print >> fd, _(__doc__)
+    if msg:
+        print >> fd, msg
+    sys.exit(code)
+
+
+
+def main():
+    try:
+        opts, args = getopt.getopt(sys.argv[1:], 'ch',
+                                   ['listcreator', 'help'])
+    except getopt.error, msg:
+        usage(1, msg)
+
+    # Defaults
+    siteadmin = 1
+    pwdesc = _('site')
+
+    for opt, arg in opts:
+        if opt in ('-h', '--help'):
+            usage(0)
+        elif opt in ('-c', '--listcreator'):
+            siteadmin = 0
+            pwdesc = _('list creator')
+
+    if len(args) == 1:
+        pw1 = args[0]
+    else:
+        try:
+            pw1 = getpass.getpass(_('New %(pwdesc)s password: '))
+            pw2 = getpass.getpass(_('Again to confirm password: '))
+            if pw1 <> pw2:
+                print _('Passwords do not match; no changes made.')
+                sys.exit(1)
+        except KeyboardInterrupt:
+            print _('Interrupted...')
+            sys.exit(0)
+    # Set the site password by writing it to a local file.  Make sure the
+    # permissions don't allow other+read.
+    Utils.set_global_password(pw1, siteadmin)
+    if Utils.check_global_password(pw1, siteadmin):
+        print _('Password changed.')
+    else:
+        print _('Password change failed.')
+
+
+
+if __name__ == '__main__':
+    main()
diff --git a/bin/newlist b/bin/newlist
new file mode 100755
index 00000000..503783d9
--- /dev/null
+++ b/bin/newlist
@@ -0,0 +1,219 @@
+#! @PYTHON@
+#
+# 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.
+
+"""Create a new, unpopulated mailing list.
+
+Usage: %(PROGRAM)s [options] [listname [listadmin-addr [admin-password]]]
+
+Options:
+
+    -l language
+    --language language
+        Make the list's preferred language `language', which must be a two
+        letter language code.
+
+    -q/--quiet
+        Normally the administrator is notified by email (after a prompt) that
+        their list has been created.  This option suppresses the prompt and
+        notification.
+
+    -h/--help
+        Print this help text and exit.
+
+You can specify as many of the arguments as you want on the command line:
+you will be prompted for the missing ones.
+
+Every Mailman list has two parameters which define the default host name for
+outgoing email, and the default URL for all web interfaces.  When you
+configured Mailman, certain defaults were calculated, but if you are running
+multiple virtual Mailman sites, then the defaults may not be appropriate for
+the list you are creating.
+
+You can specify the domain to create your new list in by spelling the listname
+like so:
+
+    mylist@www.mydom.ain
+
+where `www.mydom.ain' should be the base hostname for the URL to this virtual
+hosts's lists.  E.g. with is setting people will view the general list
+overviews at http://www.mydom.ain/mailman/listinfo.  Also, www.mydom.ain
+should be a key in the VIRTUAL_HOSTS mapping in mm_cfg.py/Defaults.py.  It
+will be looked up to give the email hostname.  If this can't be found, then
+www.mydom.ain will be used for both the web interface and the email
+interface.
+
+If you spell the list name as just `mylist', then the email hostname will be
+taken from DEFAULT_EMAIL_HOST and the url will be taken from DEFAULT_URL (as
+defined in your Defaults.py file or overridden by settings in mm_cfg.py).
+
+Note that listnames are forced to lowercase.
+"""
+
+import sys
+import os
+import getpass
+import getopt
+import sha
+
+import paths
+from Mailman import mm_cfg
+from Mailman import MailList
+from Mailman import Utils
+from Mailman import Errors
+from Mailman import Message
+from Mailman import i18n
+
+_ = i18n._
+
+PROGRAM = sys.argv[0]
+
+
+
+def usage(code, msg=''):
+    if code:
+        fd = sys.stderr
+    else:
+        fd = sys.stdout
+    print >> fd, _(__doc__)
+    if msg:
+        print >> fd, msg
+    sys.exit(code)
+
+
+
+def main():
+    try:
+        opts, args = getopt.getopt(sys.argv[1:], 'hql:',
+                                   ['help', 'quiet', 'language='])
+    except getopt.error, msg:
+        usage(1, msg)
+
+    lang = mm_cfg.DEFAULT_SERVER_LANGUAGE
+    quiet = 0
+    for opt, arg in opts:
+        if opt in ('-h', '--help'):
+            usage(0)
+        if opt in ('-q', '--quiet'):
+            quiet = 1
+        if opt in ('-l', '--language'):
+            lang = arg
+
+    # Is the language known?
+    if lang not in mm_cfg.LC_DESCRIPTIONS.keys():
+        usage(1, _('Unknown language: %(lang)s'))
+
+    if len(args) > 0:
+	listname = args[0]
+    else:
+	listname = raw_input(_('Enter the name of the list: '))
+    listname = listname.lower()
+
+    host_name = None
+    web_page_url = None
+    if '@' in listname:
+        listname, domain = listname.split('@', 1)
+        host_name = mm_cfg.VIRTUAL_HOSTS.get(domain, domain)
+        web_page_url = mm_cfg.DEFAULT_URL_PATTERN % domain
+
+    if Utils.list_exists(listname):
+        usage(1, _('List already exists: %(listname)s'))
+
+    if len(args) > 1:
+	owner_mail = args[1]
+    else:
+	owner_mail = raw_input(
+	    _('Enter the email of the person running the list: '))
+
+    if len(args) > 2:
+	listpasswd = args[2]
+    else:
+        listpasswd = getpass.getpass(_('Initial %(listname)s password: '))
+    # List passwords cannot be empty
+    listpasswd = listpasswd.strip()
+    if not listpasswd:
+        usage(1, _('The list password cannot be empty'))
+
+    mlist = MailList.MailList()
+    try:
+        pw = sha.new(listpasswd).hexdigest()
+        # Guarantee that all newly created files have the proper permission.
+        # proper group ownership should be assured by the autoconf script
+        # enforcing that all directories have the group sticky bit set
+        oldmask = os.umask(002)
+        try:
+            try:
+                mlist.Create(listname, owner_mail, pw)
+            finally:
+                os.umask(oldmask)
+        except Errors.BadListNameError, s:
+            usage(1, _('Illegal list name: %(s)s'))
+        except Errors.MMBadEmailError, s:
+            usage(1, _('Bad owner email address: %(s)s'))
+        except Errors.MMListAlreadyExistsError:
+            usage(1, _('List already exists: %(listname)s'))
+
+        # Assign domain-specific attributes
+        if host_name:
+            mlist.host_name = host_name
+            mlist.web_page_url = web_page_url
+
+        # And assign the preferred language
+        mlist.preferred_language = lang
+
+        mlist.Save()
+    finally:
+        mlist.Unlock()
+
+    # Now do the MTA-specific list creation tasks
+    if mm_cfg.MTA:
+        modname = 'Mailman.MTA.' + mm_cfg.MTA
+        __import__(modname)
+        sys.modules[modname].create(mlist)
+
+    # And send the notice to the list owner
+    if not quiet:
+        print _('Hit enter to notify %(listname)s owner...'),
+        sys.stdin.readline()
+        siteadmin = Utils.get_site_email(mlist.host_name, 'admin')
+        text = Utils.maketext(
+            'newlist.txt',
+            {'listname'    : listname,
+             'password'    : listpasswd, 
+             'admin_url'   : mlist.GetScriptURL('admin', absolute=1), 
+             'listinfo_url': mlist.GetScriptURL('listinfo', absolute=1),
+             'requestaddr' : mlist.GetRequestEmail(),
+             'siteowner'   : siteadmin,
+             }, mlist=mlist)
+        # Set the I18N language to the list's preferred language so the header
+        # will match the template language.  Stashing and restoring the old
+        # translation context is just (healthy? :) paranoia.
+        otrans = i18n.get_translation()
+        i18n.set_language(mlist.preferred_language)
+        try:
+            msg = Message.UserNotification(
+                owner_mail, siteadmin,
+                _('Your new mailing list: %(listname)s'),
+                text, mlist.preferred_language)
+            msg.send(mlist)
+        finally:
+            i18n.set_translation(otrans)
+
+
+
+if __name__ == '__main__':
+    main()
diff --git a/bin/pygettext.py b/bin/pygettext.py
new file mode 100755
index 00000000..d6e1b4f7
--- /dev/null
+++ b/bin/pygettext.py
@@ -0,0 +1,545 @@
+#! @PYTHON@
+# Originally written by Barry Warsaw <barry@zope.com>
+#
+# Minimally patched to make it even more xgettext compatible 
+# by Peter Funk <pf@artcom-gmbh.de>
+
+"""pygettext -- Python equivalent of xgettext(1)
+
+Many systems (Solaris, Linux, Gnu) provide extensive tools that ease the
+internationalization of C programs.  Most of these tools are independent of
+the programming language and can be used from within Python programs.  Martin
+von Loewis' work[1] helps considerably in this regard.
+
+There's one problem though; xgettext is the program that scans source code
+looking for message strings, but it groks only C (or C++).  Python introduces
+a few wrinkles, such as dual quoting characters, triple quoted strings, and
+raw strings.  xgettext understands none of this.
+
+Enter pygettext, which uses Python's standard tokenize module to scan Python
+source code, generating .pot files identical to what GNU xgettext[2] generates
+for C and C++ code.  From there, the standard GNU tools can be used.
+
+A word about marking Python strings as candidates for translation.  GNU
+xgettext recognizes the following keywords: gettext, dgettext, dcgettext, and
+gettext_noop.  But those can be a lot of text to include all over your code.
+C and C++ have a trick: they use the C preprocessor.  Most internationalized C
+source includes a #define for gettext() to _() so that what has to be written
+in the source is much less.  Thus these are both translatable strings:
+
+    gettext("Translatable String")
+    _("Translatable String")
+
+Python of course has no preprocessor so this doesn't work so well.  Thus,
+pygettext searches only for _() by default, but see the -k/--keyword flag
+below for how to augment this.
+
+ [1] http://www.python.org/workshops/1997-10/proceedings/loewis.html
+ [2] http://www.gnu.org/software/gettext/gettext.html
+
+NOTE: pygettext attempts to be option and feature compatible with GNU xgettext
+where ever possible.  However some options are still missing or are not fully
+implemented.  Also, xgettext's use of command line switches with option
+arguments is broken, and in these cases, pygettext just defines additional
+switches.
+
+Usage: pygettext [options] inputfile ...
+
+Options:
+
+    -a
+    --extract-all
+        Extract all strings.
+
+    -d name
+    --default-domain=name
+        Rename the default output file from messages.pot to name.pot.
+
+    -E
+    --escape
+        Replace non-ASCII characters with octal escape sequences.
+
+    -D
+    --docstrings
+        Extract module, class, method, and function docstrings.  These do not
+        need to be wrapped in _() markers, and in fact cannot be for Python to
+        consider them docstrings. (See also the -X option).
+
+    -h
+    --help
+        Print this help message and exit.
+
+    -k word
+    --keyword=word
+        Keywords to look for in addition to the default set, which are:
+        %(DEFAULTKEYWORDS)s
+
+        You can have multiple -k flags on the command line.
+
+    -K
+    --no-default-keywords
+        Disable the default set of keywords (see above).  Any keywords
+        explicitly added with the -k/--keyword option are still recognized.
+
+    --no-location
+        Do not write filename/lineno location comments.
+
+    -n
+    --add-location
+        Write filename/lineno location comments indicating where each
+        extracted string is found in the source.  These lines appear before
+        each msgid.  The style of comments is controlled by the -S/--style
+        option.  This is the default.
+
+    -o filename
+    --output=filename
+        Rename the default output file from messages.pot to filename.  If
+        filename is `-' then the output is sent to standard out.
+
+    -p dir
+    --output-dir=dir
+        Output files will be placed in directory dir.
+
+    -S stylename
+    --style stylename
+        Specify which style to use for location comments.  Two styles are
+        supported:
+
+        Solaris  # File: filename, line: line-number
+        GNU      #: filename:line
+
+        The style name is case insensitive.  GNU style is the default.
+
+    -v
+    --verbose
+        Print the names of the files being processed.
+
+    -V
+    --version
+        Print the version of pygettext and exit.
+
+    -w columns
+    --width=columns
+        Set width of output to columns.
+
+    -x filename
+    --exclude-file=filename
+        Specify a file that contains a list of strings that are not be
+        extracted from the input files.  Each string to be excluded must
+        appear on a line by itself in the file.
+
+    -X filename
+    --no-docstrings=filename
+        Specify a file that contains a list of files (one per line) that
+        should not have their docstrings extracted.  This is only useful in
+        conjunction with the -D option above.
+
+If `inputfile' is -, standard input is read.
+"""
+
+import os
+import sys
+import time
+import getopt
+import tokenize
+import operator
+
+# for selftesting
+try:
+    import fintl
+    _ = fintl.gettext
+except ImportError:
+    def _(s): return s
+
+__version__ = '1.4'
+
+default_keywords = ['_']
+DEFAULTKEYWORDS = ', '.join(default_keywords)
+
+EMPTYSTRING = ''
+
+
+
+# The normal pot-file header. msgmerge and Emacs's po-mode work better if it's
+# there.
+pot_header = _('''\
+# SOME DESCRIPTIVE TITLE.
+# Copyright (C) YEAR ORGANIZATION
+# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
+#
+msgid ""
+msgstr ""
+"Project-Id-Version: PACKAGE VERSION\\n"
+"POT-Creation-Date: %(time)s\\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\\n"
+"Last-Translator: FULL NAME <EMAIL@ADDRESS>\\n"
+"Language-Team: LANGUAGE <LL@li.org>\\n"
+"MIME-Version: 1.0\\n"
+"Content-Type: text/plain; charset=CHARSET\\n"
+"Content-Transfer-Encoding: ENCODING\\n"
+"Generated-By: pygettext.py %(version)s\\n"
+
+''')
+
+
+def usage(code, msg=''):
+    if code:
+        fd = sys.stderr
+    else:
+        fd = sys.stdout
+    print >> fd, _(__doc__) % globals()
+    if msg:
+        print >> fd, msg
+    sys.exit(code)
+
+
+
+escapes = []
+
+def make_escapes(pass_iso8859):
+    global escapes
+    if pass_iso8859:
+        # Allow iso-8859 characters to pass through so that e.g. 'msgid
+        # "Höhe"' would result not result in 'msgid "H\366he"'.  Otherwise we
+        # escape any character outside the 32..126 range.
+        mod = 128
+    else:
+        mod = 256
+    for i in range(256):
+        if 32 <= (i % mod) <= 126:
+            escapes.append(chr(i))
+        else:
+            escapes.append("\\%03o" % i)
+    escapes[ord('\\')] = '\\\\'
+    escapes[ord('\t')] = '\\t'
+    escapes[ord('\r')] = '\\r'
+    escapes[ord('\n')] = '\\n'
+    escapes[ord('\"')] = '\\"'
+
+
+def escape(s):
+    global escapes
+    s = list(s)
+    for i in range(len(s)):
+        s[i] = escapes[ord(s[i])]
+    return EMPTYSTRING.join(s)
+
+
+def safe_eval(s):
+    # unwrap quotes, safely
+    return eval(s, {'__builtins__':{}}, {})
+
+
+def normalize(s):
+    # This converts the various Python string types into a format that is
+    # appropriate for .po files, namely much closer to C style.
+    lines = s.split('\n')
+    if len(lines) == 1:
+        s = '"' + escape(s) + '"'
+    else:
+        if not lines[-1]:
+            del lines[-1]
+            lines[-1] = lines[-1] + '\n'
+        for i in range(len(lines)):
+            lines[i] = escape(lines[i])
+        lineterm = '\\n"\n"'
+        s = '""\n"' + lineterm.join(lines) + '"'
+    return s
+
+
+
+class TokenEater:
+    def __init__(self, options):
+        self.__options = options
+        self.__messages = {}
+        self.__state = self.__waiting
+        self.__data = []
+        self.__lineno = -1
+        self.__freshmodule = 1
+        self.__curfile = None
+
+    def __call__(self, ttype, tstring, stup, etup, line):
+        # dispatch
+##        import token
+##        print >> sys.stderr, 'ttype:', token.tok_name[ttype], \
+##              'tstring:', tstring
+        self.__state(ttype, tstring, stup[0])
+
+    def __waiting(self, ttype, tstring, lineno):
+        opts = self.__options
+        # Do docstring extractions, if enabled
+        if opts.docstrings and not opts.nodocstrings.get(self.__curfile):
+            # module docstring?
+            if self.__freshmodule:
+                if ttype == tokenize.STRING:
+                    self.__addentry(safe_eval(tstring), lineno, isdocstring=1)
+                    self.__freshmodule = 0
+                elif ttype not in (tokenize.COMMENT, tokenize.NL):
+                    self.__freshmodule = 0
+                return
+            # class docstring?
+            if ttype == tokenize.NAME and tstring in ('class', 'def'):
+                self.__state = self.__suiteseen
+                return
+        if ttype == tokenize.NAME and tstring in opts.keywords:
+            self.__state = self.__keywordseen
+
+    def __suiteseen(self, ttype, tstring, lineno):
+        # ignore anything until we see the colon
+        if ttype == tokenize.OP and tstring == ':':
+            self.__state = self.__suitedocstring
+
+    def __suitedocstring(self, ttype, tstring, lineno):
+        # ignore any intervening noise
+        if ttype == tokenize.STRING:
+            self.__addentry(safe_eval(tstring), lineno, isdocstring=1)
+            self.__state = self.__waiting
+        elif ttype not in (tokenize.NEWLINE, tokenize.INDENT,
+                           tokenize.COMMENT):
+            # there was no class docstring
+            self.__state = self.__waiting
+
+    def __keywordseen(self, ttype, tstring, lineno):
+        if ttype == tokenize.OP and tstring == '(':
+            self.__data = []
+            self.__lineno = lineno
+            self.__state = self.__openseen
+        else:
+            self.__state = self.__waiting
+
+    def __openseen(self, ttype, tstring, lineno):
+        if ttype == tokenize.OP and tstring == ')':
+            # We've seen the last of the translatable strings.  Record the
+            # line number of the first line of the strings and update the list 
+            # of messages seen.  Reset state for the next batch.  If there
+            # were no strings inside _(), then just ignore this entry.
+            if self.__data:
+                self.__addentry(EMPTYSTRING.join(self.__data))
+            self.__state = self.__waiting
+        elif ttype == tokenize.STRING:
+            self.__data.append(safe_eval(tstring))
+        # TBD: should we warn if we seen anything else?
+
+    def __addentry(self, msg, lineno=None, isdocstring=0):
+        if lineno is None:
+            lineno = self.__lineno
+        if not msg in self.__options.toexclude:
+            entry = (self.__curfile, lineno)
+            self.__messages.setdefault(msg, {})[entry] = isdocstring
+
+    def set_filename(self, filename):
+        self.__curfile = filename
+        self.__freshmodule = 1
+
+    def write(self, fp):
+        options = self.__options
+        timestamp = time.ctime(time.time())
+        # The time stamp in the header doesn't have the same format as that
+        # generated by xgettext...
+        print >> fp, pot_header % {'time': timestamp, 'version': __version__}
+        # Sort the entries.  First sort each particular entry's keys, then
+        # sort all the entries by their first item.
+        reverse = {}
+        for k, v in self.__messages.items():
+            keys = v.keys()
+            keys.sort()
+            reverse.setdefault(tuple(keys), []).append((k, v))
+        rkeys = reverse.keys()
+        rkeys.sort()
+        for rkey in rkeys:
+            rentries = reverse[rkey]
+            rentries.sort()
+            for k, v in rentries:
+                isdocstring = 0
+                # If the entry was gleaned out of a docstring, then add a
+                # comment stating so.  This is to aid translators who may wish
+                # to skip translating some unimportant docstrings.
+                if reduce(operator.__add__, v.values()):
+                    isdocstring = 1
+                # k is the message string, v is a dictionary-set of (filename,
+                # lineno) tuples.  We want to sort the entries in v first by
+                # file name and then by line number.
+                v = v.keys()
+                v.sort()
+                if not options.writelocations:
+                    pass
+                # location comments are different b/w Solaris and GNU:
+                elif options.locationstyle == options.SOLARIS:
+                    for filename, lineno in v:
+                        d = {'filename': filename, 'lineno': lineno}
+                        print >>fp, _(
+                            '# File: %(filename)s, line: %(lineno)d') % d
+                elif options.locationstyle == options.GNU:
+                    # fit as many locations on one line, as long as the
+                    # resulting line length doesn't exceeds 'options.width'
+                    locline = '#:'
+                    for filename, lineno in v:
+                        d = {'filename': filename, 'lineno': lineno}
+                        s = _(' %(filename)s:%(lineno)d') % d
+                        if len(locline) + len(s) <= options.width:
+                            locline = locline + s
+                        else:
+                            print >> fp, locline
+                            locline = "#:" + s
+                    if len(locline) > 2:
+                        print >> fp, locline
+                if isdocstring:
+                    print >> fp, '#, docstring'
+                print >> fp, 'msgid', normalize(k)
+                print >> fp, 'msgstr ""\n'
+
+
+
+def main():
+    global default_keywords
+    try:
+        opts, args = getopt.getopt(
+            sys.argv[1:],
+            'ad:DEhk:Kno:p:S:Vvw:x:X:',
+            ['extract-all', 'default-domain=', 'escape', 'help',
+             'keyword=', 'no-default-keywords',
+             'add-location', 'no-location', 'output=', 'output-dir=',
+             'style=', 'verbose', 'version', 'width=', 'exclude-file=',
+             'docstrings', 'no-docstrings',
+             ])
+    except getopt.error, msg:
+        usage(1, msg)
+
+    # for holding option values
+    class Options:
+        # constants
+        GNU = 1
+        SOLARIS = 2
+        # defaults
+        extractall = 0 # FIXME: currently this option has no effect at all.
+        escape = 0
+        keywords = []
+        outpath = ''
+        outfile = 'messages.pot'
+        writelocations = 1
+        locationstyle = GNU
+        verbose = 0
+        width = 78
+        excludefilename = ''
+        docstrings = 0
+        nodocstrings = {}
+
+    options = Options()
+    locations = {'gnu' : options.GNU,
+                 'solaris' : options.SOLARIS,
+                 }
+
+    # parse options
+    for opt, arg in opts:
+        if opt in ('-h', '--help'):
+            usage(0)
+        elif opt in ('-a', '--extract-all'):
+            options.extractall = 1
+        elif opt in ('-d', '--default-domain'):
+            options.outfile = arg + '.pot'
+        elif opt in ('-E', '--escape'):
+            options.escape = 1
+        elif opt in ('-D', '--docstrings'):
+            options.docstrings = 1
+        elif opt in ('-k', '--keyword'):
+            options.keywords.append(arg)
+        elif opt in ('-K', '--no-default-keywords'):
+            default_keywords = []
+        elif opt in ('-n', '--add-location'):
+            options.writelocations = 1
+        elif opt in ('--no-location',):
+            options.writelocations = 0
+        elif opt in ('-S', '--style'):
+            options.locationstyle = locations.get(arg.lower())
+            if options.locationstyle is None:
+                usage(1, _('Invalid value for --style: %s') % arg)
+        elif opt in ('-o', '--output'):
+            options.outfile = arg
+        elif opt in ('-p', '--output-dir'):
+            options.outpath = arg
+        elif opt in ('-v', '--verbose'):
+            options.verbose = 1
+        elif opt in ('-V', '--version'):
+            print _('pygettext.py (xgettext for Python) %s') % __version__
+            sys.exit(0)
+        elif opt in ('-w', '--width'):
+            try:
+                options.width = int(arg)
+            except ValueError:
+                usage(1, _('--width argument must be an integer: %s') % arg)
+        elif opt in ('-x', '--exclude-file'):
+            options.excludefilename = arg
+        elif opt in ('-X', '--no-docstrings'):
+            fp = open(arg)
+            try:
+                while 1:
+                    line = fp.readline()
+                    if not line:
+                        break
+                    options.nodocstrings[line[:-1]] = 1
+            finally:
+                fp.close()
+
+    # calculate escapes
+    make_escapes(options.escape)
+
+    # calculate all keywords
+    options.keywords.extend(default_keywords)
+
+    # initialize list of strings to exclude
+    if options.excludefilename:
+        try:
+            fp = open(options.excludefilename)
+            options.toexclude = fp.readlines()
+            fp.close()
+        except IOError:
+            print >> sys.stderr, _(
+                "Can't read --exclude-file: %s") % options.excludefilename
+            sys.exit(1)
+    else:
+        options.toexclude = []
+
+    # slurp through all the files
+    eater = TokenEater(options)
+    for filename in args:
+        if filename == '-':
+            if options.verbose:
+                print _('Reading standard input')
+            fp = sys.stdin
+            closep = 0
+        else:
+            if options.verbose:
+                print _('Working on %s') % filename
+            fp = open(filename)
+            closep = 1
+        try:
+            eater.set_filename(filename)
+            try:
+                tokenize.tokenize(fp.readline, eater)
+            except tokenize.TokenError, e:
+                print >> sys.stderr, '%s: %s, line %d, column %d' % (
+                    e[0], filename, e[1][0], e[1][1])
+        finally:
+            if closep:
+                fp.close()
+
+    # write the output
+    if options.outfile == '-':
+        fp = sys.stdout
+        closep = 0
+    else:
+        if options.outpath:
+            options.outfile = os.path.join(options.outpath, options.outfile)
+        fp = open(options.outfile, 'w')
+        closep = 1
+    try:
+        eater.write(fp)
+    finally:
+        if closep:
+            fp.close()
+
+
+if __name__ == '__main__':
+    main()
+    # some more test strings
+    _(u'a unicode string')
diff --git a/bin/qrunner b/bin/qrunner
new file mode 100644
index 00000000..bb2f62d3
--- /dev/null
+++ b/bin/qrunner
@@ -0,0 +1,270 @@
+#! @PYTHON@
+
+# Copyright (C) 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.
+
+"""Run one or more qrunners, once or repeatedly.
+
+Each named runner class is run in round-robin fashion.  In other words, the
+first named runner is run to consume all the files currently in its
+directory.  When that qrunner is done, the next one is run to consume all the
+files in /its/ directory, and so on.  The number of total iterations can be
+given on the command line.
+
+Usage: %(PROGRAM)s [options]
+
+Options:
+
+    -r runner[:slice:range]
+    --runner=runner[:slice:range]
+        Run the named qrunner, which must be one of the strings returned by
+        the -l option.  Optional slice:range if given, is used to assign
+        multiple qrunner processes to a queue.  range is the total number of
+        qrunners for this queue while slice is the number of this qrunner from
+        [0..range).
+
+        If using the slice:range form, you better make sure that each qrunner
+        for the queue is given the same range value.  If slice:runner is not
+        given, then 1:1 is used.
+
+        Multiple -r options may be given, in which case each qrunner will run
+        once in round-robin fashion.  The special runner `All' is shorthand
+        for a qrunner for each listed by the -l option.
+
+    --once
+    -o
+        Run each named qrunner exactly once through its main loop.  Otherwise,
+        each qrunner runs indefinitely, until the process receives a SIGTERM
+        or SIGINT.
+
+    -l/--list
+        Shows the available qrunner names and exit.
+
+    -v/--verbose
+        Spit out more debugging information to the logs/qrunner log file.
+
+    -s/--subproc
+        This should only be used when running qrunner as a subprocess of the
+        mailmanctl startup script.  It changes some of the exit-on-error
+        behavior to work better with that framework.
+
+    -h/--help
+        Print this message and exit.
+
+runner is required unless -l or -h is given, and it must be one of the names
+displayed by the -l switch.
+"""
+
+import sys
+import getopt
+import signal
+
+import paths
+from Mailman import mm_cfg
+from Mailman.i18n import _
+from Mailman.Logging.Syslog import syslog
+from Mailman.Logging.Utils import LogStdErr
+
+PROGRAM = sys.argv[0]
+COMMASPACE = ', '
+
+# Flag which says whether we're running under mailmanctl or not.
+AS_SUBPROC = 0
+
+LogStdErr('error', 'qrunner', manual_reprime=0)
+
+
+
+def usage(code, msg=''):
+    if code:
+        fd = sys.stderr
+    else:
+        fd = sys.stdout
+    print >> fd, _(__doc__)
+    if msg:
+        print >> fd, msg
+    sys.exit(code)
+
+
+
+def make_qrunner(name, slice, range, once=0):
+    modulename = 'Mailman.Queue.' + name
+    try:
+        __import__(modulename)
+    except ImportError, e:
+        if AS_SUBPROC:
+            # Exit with SIGTERM exit code so mailmanctl won't try to restart us
+            print >> sys.stderr, 'Cannot import runner module', modulename
+            print >> sys.stderr, e
+            sys.exit(signal.SIGTERM)
+        else:
+            usage(1, e)
+    qrclass = getattr(sys.modules[modulename], name)
+    if once:
+        # Subclass to hack in the setting of the stop flag in _doperiodic()
+        class Once(qrclass):
+            def _doperiodic(self):
+                self.stop()
+        qrunner = Once(slice, range)
+    else:
+        qrunner = qrclass(slice, range)
+    return qrunner
+
+
+
+def set_signals(loop):
+    # Set up the SIGTERM handler for stopping the loop
+    def sigterm_handler(signum, frame, loop=loop):
+        # Exit the qrunner cleanly
+        loop.stop()
+        loop.status = signal.SIGTERM
+        syslog('qrunner', '%s qrunner caught SIGTERM.  Stopping.', loop.name())
+    signal.signal(signal.SIGTERM, sigterm_handler)
+    # Set up the SIGINT handler for stopping the loop.  For us, SIGINT is
+    # the same as SIGTERM, but our parent treats the exit statuses
+    # differently (it restarts a SIGINT but not a SIGTERM).
+    def sigint_handler(signum, frame, loop=loop):
+        # Exit the qrunner cleanly
+        loop.stop()
+        loop.status = signal.SIGINT
+        syslog('qrunner', '%s qrunner caught SIGINT.  Stopping.', loop.name())
+    signal.signal(signal.SIGINT, sigint_handler)
+    # SIGHUP just tells us to close our log files.  They'll be
+    # automatically reopened at the next log print :)
+    def sighup_handler(signum, frame, loop=loop):
+        syslog.close()
+        syslog('qrunner', '%s qrunner caught SIGHUP.  Reopening logs.',
+               loop.name())
+    signal.signal(signal.SIGHUP, sighup_handler)
+
+
+
+def main():
+    global AS_SUBPROC
+    try:
+        opts, args = getopt.getopt(
+            sys.argv[1:], 'hlor:vs',
+            ['help', 'list', 'once', 'runner=', 'verbose', 'subproc'])
+    except getopt.error, msg:
+        usage(1, msg)
+
+    once = 0
+    runners = []
+    verbose = 0
+    for opt, arg in opts:
+        if opt in ('-h', '--help'):
+            usage(0)
+        elif opt in ('-l', '--list'):
+            for runnername, slices in mm_cfg.QRUNNERS:
+                if runnername.endswith('Runner'):
+                    name = runnername[:-len('Runner')]
+                else:
+                    name = runnername
+                print _('%(name)s runs the %(runnername)s qrunner')
+            print _('All runs all the above qrunners')
+            sys.exit(0)
+        elif opt in ('-o', '--once'):
+            once = 1
+        elif opt in ('-r', '--runner'):
+            runnerspec = arg
+            parts = runnerspec.split(':')
+            if len(parts) == 1:
+                runner = parts[0]
+                slice = 1
+                range = 1
+            elif len(parts) == 3:
+                runner = parts[0]
+                try:
+                    slice = int(parts[1])
+                    range = int(parts[2])
+                except ValueError:
+                    usage(1, 'Bad runner specification: %(runnerspec)s')
+            else:
+                usage(1, 'Bad runner specification: %(runnerspec)s')
+            if runner == 'All':
+                for runnername, slices in mm_cfg.QRUNNERS:
+                    runners.append((runnername, slice, range))
+            else:
+                if runner.endswith('Runner'):
+                    runners.append((runner, slice, range))
+                else:
+                    runners.append((runner + 'Runner', slice, range))
+        elif opt in ('-s', '--subproc'):
+            AS_SUBPROC = 1
+        elif opt in ('-v', '--verbose'):
+            verbose = 1
+
+    if len(args) <> 0:
+        usage(1)
+    if len(runners) == 0:
+        usage(1, _('No runner name given.'))
+
+    # Fast track for one infinite runner
+    if len(runners) == 1 and not once:
+        qrunner = make_qrunner(*runners[0])
+        class Loop:
+            status = 0
+            def __init__(self, qrunner):
+                self.__qrunner = qrunner
+            def name(self):
+                return self.__qrunner.__class__.__name__
+            def stop(self):
+                self.__qrunner.stop()
+        loop = Loop(qrunner)
+        set_signals(loop)
+        # Now start up the main loop
+        syslog('qrunner', '%s qrunner started.', loop.name())
+        qrunner.run()
+        syslog('qrunner', '%s qrunner exiting.', loop.name())
+    else:
+        # Anything else we have to handle a bit more specially
+        qrunners = []
+        for runner, slice, range in runners:
+            qrunner = make_qrunner(runner, slice, range, 1)
+            qrunners.append(qrunner)
+        # This class is used to manage the main loop
+        class Loop:
+            status = 0
+            def __init__(self):
+                self.__isdone = 0
+            def name(self):
+                return 'Main loop'
+            def stop(self):
+                self.__isdone = 1
+            def isdone(self):
+                return self.__isdone
+        loop = Loop()
+        set_signals(loop)
+        syslog('qrunner', 'Main qrunner loop started.')
+        while not loop.isdone():
+            for qrunner in qrunners:
+                # In case the SIGTERM came in the middle of this iteration
+                if loop.isdone():
+                    break
+                if verbose:
+                    syslog('qrunner', 'Now doing a %s qrunner iteration',
+                           qrunner.__class__.__bases__[0].__name__)
+                qrunner.run()
+            if once:
+                break
+        syslog('qrunner', 'Main qrunner loop exiting.')
+    # All done
+    sys.exit(loop.status)
+
+
+
+if __name__ == '__main__':
+    main()
diff --git a/bin/remove_members b/bin/remove_members
new file mode 100755
index 00000000..888dfa51
--- /dev/null
+++ b/bin/remove_members
@@ -0,0 +1,179 @@
+#! @PYTHON@
+#
+# 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.
+#
+"""Remove members from a list.
+
+Usage:
+    remove_members [options] [listname] [addr1 ...]
+
+Options:
+
+    --file=file
+    -f file
+        Remove member addresses found in the given file.  If file is
+        `-', read stdin.
+
+    --all
+    -a
+        Remove all members of the mailing list.
+       (mutually exclusive with --fromall)
+
+    --fromall
+       Removes the given addresses from all the lists on this system
+       regardless of virtual domains if you have any.  This option cannot be
+       used -a/--all.  Also, you should not specify a listname when using this
+       option.
+
+    --nouserack
+    -n
+        Don't send the user acknowledgements.
+
+    --noadminack
+    -N
+        Don't send the admin acknowledgements.
+
+    --help
+    -h
+        Print this help message and exit.
+
+    listname is the name of the mailing list to use.
+
+    addr1 ... are additional addresses to remove.
+
+"""
+
+import sys
+import getopt
+
+import paths
+from Mailman import MailList
+from Mailman import Utils
+from Mailman import Errors
+from Mailman.i18n import _
+
+
+
+def usage(code, msg=''):
+    if code:
+        fd = sys.stderr
+    else:
+        fd = sys.stdout
+    print >> fd, _(__doc__)
+    if msg:
+        print >> fd, msg
+    sys.exit(code)
+
+
+def ReadFile(filename):
+    lines = []
+    if filename == "-":
+        fp = sys.stdin
+        closep = 0
+    else:
+        fp = open(filename)
+        closep = 1
+    lines = filter(None, [line.strip() for line in fp.readlines()])
+    if closep:
+        fp.close()
+    return lines
+
+
+
+def main():
+    try:
+        opts, args = getopt.getopt(
+            sys.argv[1:], 'naf:hN',
+            ['all', 'fromall', 'file=', 'help', 'nouserack', 'noadminack'])
+    except getopt.error, msg:
+        usage(1, msg)
+
+    if len(args) < 1:
+        usage(1)
+
+    filename = None
+    all = 0
+    alllists = 0
+    userack = 1
+    admin_notif = 1
+
+    for opt, arg in opts:
+        if opt in ('-h', '--help'):
+            usage(0)
+        elif opt in ('-f', '--file'):
+            filename = arg
+        elif opt in ('-a', '--all'):
+            all = 1
+        elif opt == '--fromall':
+            alllists = 1
+        elif opt in ('-n', '--nouserack'):
+            userack = 0
+        elif opt in ('-N', '--noadminack'):
+            admin_notif = 0
+
+    # You probably don't want to delete all the users of all the lists -- Marc
+    if all and alllists:
+       usage(1)
+
+    if alllists:
+       addresses = args
+    else:
+       listname = args[0].lower().strip()
+       addresses = args[1:]
+
+    if alllists:
+        listnames = Utils.list_names()
+    else:
+        listnames = [listname]
+
+    if filename:
+        try:
+            addresses = addresses + ReadFile(filename)
+        except IOError:
+            print _('Could not open file for reading: %(filename)s.')
+
+    for listname in listnames:
+       try:
+           # open locked
+           mlist = MailList.MailList(listname)
+       except Errors.MMListError:
+           print _('Error opening list %(listname)s... skipping.')
+           continue
+
+       if all:
+           addresses = mlist.getMembers()
+
+       try:
+           for addr in addresses:
+               if not mlist.isMember(addr):
+                   if not alllists:
+                       print _('No such member: %(addr)s')
+                   continue
+               mlist.ApprovedDeleteMember(addr,
+                                          'bin/remove_members',
+                                          admin_notif,
+                                          userack)
+               if alllists:
+                   print _("User `%(addr)s' removed from list: %(listname)s.")
+           mlist.Save()
+       finally:
+           mlist.Unlock()
+
+
+
+if __name__ == '__main__':
+    main()
diff --git a/bin/rmlist b/bin/rmlist
new file mode 100755
index 00000000..6ff0b5c1
--- /dev/null
+++ b/bin/rmlist
@@ -0,0 +1,138 @@
+#! @PYTHON@
+#
+# 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.
+
+"""Remove the components of a mailing list with impunity - beware!
+
+This removes (almost) all traces of a mailing list.  By default, the lists
+archives are not removed, which is very handy for retiring old lists.
+
+Usage:
+    rmlist [-a] [-h] listname
+
+Where:
+    --archives
+    -a
+        Remove the list's archives too, or if the list has already been
+        deleted, remove any residual archives.
+
+    --help
+    -h
+        Print this help message and exit.
+
+"""
+
+import os
+import sys
+import getopt
+import shutil
+
+import paths
+from Mailman import mm_cfg
+from Mailman import Utils
+from Mailman import MailList
+from Mailman.i18n import _
+
+
+
+def usage(code, msg=''):
+    if code:
+        fd = sys.stderr
+    else:
+        fd = sys.stdout
+    print >> fd, _(__doc__)
+    if msg:
+        print >> fd, msg
+    sys.exit(code)
+
+
+
+def remove_it(listname, dir, msg):
+    if os.path.islink(dir):
+        print _('Removing %(msg)s')
+        os.unlink(dir)
+    elif os.path.isdir(dir):
+        print _('Removing %(msg)s')
+        shutil.rmtree(dir)
+    else:
+        print _('%(listname)s %(msg)s not found as %(dir)s')
+
+
+
+def main():
+    try:
+        opts, args = getopt.getopt(sys.argv[1:], 'ah',
+                                   ['archives', 'help'])
+    except getopt.error, msg:
+        usage(1, msg)
+
+    if len(args) <> 1:
+        usage(1)
+    listname = args[0].lower().strip()
+
+    removeArchives = 0
+    for opt, arg in opts:
+        if opt in ('-a', '--archives'):
+            removeArchives = 1
+        elif opt in ('-h', '--help'):
+            usage(0)
+
+    if not Utils.list_exists(listname):
+	if not removeArchives:
+	    usage(1, _('No such list (or list already deleted): %(listname)s'))
+	else:
+	    print _(
+                'No such list: %(listname)s.  Removing its residual archives.')
+
+    if not removeArchives:
+        print _('Not removing archives.  Reinvoke with -a to remove them.')
+
+
+    REMOVABLES = []
+    if Utils.list_exists(listname):
+	mlist = MailList.MailList(listname, lock=0)
+
+	# Do the MTA-specific list deletion tasks
+	if mm_cfg.MTA:
+	    modname = 'Mailman.MTA.' + mm_cfg.MTA
+	    __import__(modname)
+	    sys.modules[modname].remove(mlist)
+
+	REMOVABLES = [
+	    (os.path.join('lists', listname), _('list info')),
+            ]
+
+    if removeArchives:
+        REMOVABLES.extend([
+	    (os.path.join('archives', 'private', listname),
+             _('private archives')),
+	    (os.path.join('archives', 'private', listname + '.mbox'),
+             _('private archives')),
+	    (os.path.join('archives', 'public', listname),
+             _('public archives')),
+	    (os.path.join('archives', 'public', listname + '.mbox'),
+             _('public archives')),
+            ])
+
+    for dirtmpl, msg in REMOVABLES:
+        dir = os.path.join(mm_cfg.VAR_PREFIX, dirtmpl)
+        remove_it(listname, dir, msg)
+
+
+
+if __name__ == '__main__':
+    main()
diff --git a/bin/sync_members b/bin/sync_members
new file mode 100755
index 00000000..1bf9a454
--- /dev/null
+++ b/bin/sync_members
@@ -0,0 +1,286 @@
+#! @PYTHON@
+#
+# 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.
+
+"""Synchronize a mailing list's membership with a flat file.
+
+This script is useful if you have a Mailman mailing list and a sendmail
+:include: style list of addresses (also as is used in Majordomo).  For every
+address in the file that does not appear in the mailing list, the address is
+added.  For every address in the mailing list that does not appear in the
+file, the address is removed.  Other options control what happens when an
+address is added or removed.
+
+Usage: %(PROGRAM)s [options] -f file listname
+
+Where `options' are:
+
+    --no-change
+    -n
+        Don't actually make the changes.  Instead, print out what would be
+        done to the list.
+
+    --welcome-msg[=<yes|no>]
+    -w[=<yes|no>]
+        Sets whether or not to send the newly added members a welcome
+        message, overriding whatever the list's `send_welcome_msg' setting
+        is.  With -w=yes or -w, the welcome message is sent.  With -w=no, no
+        message is sent.
+
+    --goodbye-msg[=<yes|no>]
+    -g[=<yes|no>]
+        Sets whether or not to send the goodbye message to removed members,
+        overriding whatever the list's `send_goodbye_msg' setting is.  With
+        -g=yes or -g, the goodbye message is sent.  With -g=no, no message is
+        sent.
+
+    --digest[=<yes|no>]
+    -d[=<yes|no>]
+        Selects whether to make newly added members receive messages in
+        digests.  With -d=yes or -d, they become digest members.  With -d=no
+        (or if no -d option given) they are added as regular members.
+
+    --notifyadmin[=<yes|no>]
+    -a[=<yes|no>]
+        Specifies whether the admin should be notified for each subscription
+        or unsubscription.  If you're adding a lot of addresses, you
+        definitely want to turn this off!  With -a=yes or -a, the admin is
+        notified.  With -a=no, the admin is not notified.  With no -a option,
+        the default for the list is used.
+
+    --file <filename | ->
+    -f <filename | ->
+        This option is required.  It specifies the flat file to synchronize
+        against.  Email addresses must appear one per line.  If filename is
+        `-' then stdin is used.
+
+    --help
+    -h
+        Print this message.
+
+    listname
+        Required.  This specifies the list to synchronize.
+"""
+
+import sys
+
+import paths
+# Import this /after/ paths so that the sys.path is properly hacked
+import email.Utils
+
+from Mailman import MailList
+from Mailman import Errors
+from Mailman import Utils
+from Mailman.UserDesc import UserDesc
+from Mailman.i18n import _
+
+
+
+PROGRAM = sys.argv[0]
+
+def usage(code, msg=''):
+    if code:
+        fd = sys.stderr
+    else:
+        fd = sys.stdout
+    print >> fd, _(__doc__)
+    if msg:
+        print >> fd, msg
+    sys.exit(code)
+
+
+
+def yesno(opt):
+    i = opt.find('=')
+    yesno = opt[i+1:].lower()
+    if yesno in ('y', 'yes'):
+        return 1
+    elif yesno in ('n', 'no'):
+        return 0
+    else:
+        usage(1, _('Bad choice: %(yesno)s'))
+        # no return
+
+
+def main():
+    dryrun = 0
+    digest = 0
+    welcome = None
+    goodbye = None
+    filename = None
+    listname = None
+    notifyadmin = None
+
+    # TBD: can't use getopt with this command line syntax, which is broken and
+    # should be changed to be getopt compatible.
+    i = 1
+    while i < len(sys.argv):
+        opt = sys.argv[i]
+        if opt in ('-h', '--help'):
+            usage(0)
+        elif opt in ('-n', '--no-change'):
+            dryrun = 1
+            i += 1
+            print _('Dry run mode')
+        elif opt in ('-d', '--digest'):
+            digest = 1
+            i += 1
+        elif opt.startswith('-d=') or opt.startswith('--digest='):
+            digest = yesno(opt)
+            i += 1
+        elif opt in ('-w', '--welcome-msg'):
+            welcome = 1
+            i += 1
+        elif opt.startswith('-w=') or opt.startswith('--welcome-msg='):
+            welcome = yesno(opt)
+            i += 1
+        elif opt in ('-g', '--goodbye-msg'):
+            goodbye = 1
+            i += 1
+        elif opt.startswith('-g=') or opt.startswith('--goodbye-msg='):
+            goodbye = yesno(opt)
+            i += 1
+        elif opt in ('-f', '--file'):
+            if filename is not None:
+                usage(1, _('Only one -f switch allowed'))
+            try:
+                filename = sys.argv[i+1]
+            except IndexError:
+                usage(1, _('No argument to -f given'))
+            i += 2
+        elif opt in ('-a', '--notifyadmin'):
+            notifyadmin = 1
+            i += 1
+        elif opt.startswith('-a=') or opt.startswith('--notifyadmin='):
+            notifyadmin = yesno(opt)
+            i += 1
+        elif opt[0] == '-':
+            usage(1, _('Illegal option: %(opt)s'))
+        else:
+            try:
+                listname = sys.argv[i].lower()
+                i += 1
+            except IndexError:
+                usage(1, _('No listname given'))
+            break
+
+    if listname is None or filename is None:
+        usage(1, _('Must have a listname and a filename'))
+
+    # read the list of addresses to sync to from the file
+    if filename == '-':
+        filemembers = sys.stdin.readlines()
+    else:
+        try:
+            fp = open(filename)
+        except IOError, (code, msg):
+            usage(1, _('Cannot read address file: %(filename)s: %(msg)s'))
+        try:
+            filemembers = fp.readlines()
+        finally:
+            fp.close()
+
+    # strip out lines we don't care about, they are comments (# in first
+    # non-whitespace) or are blank
+    for i in range(len(filemembers)-1, -1, -1):
+        addr = filemembers[i].strip()
+        if addr == '' or addr[:1] == '#':
+            del filemembers[i]
+            print _('Ignore  :  %(addr)30s')
+
+    # first filter out any invalid addresses
+    filemembers = email.Utils.getaddresses(filemembers)
+    invalid = 0
+    for name, addr in filemembers:
+        try:
+            Utils.ValidateEmail(addr)
+        except Errors.EmailAddressError:
+            print _('Invalid :  %(addr)30s')
+            invalid = 1
+    if invalid:
+        print _('You must fix the preceding invalid addresses first.')
+        sys.exit(1)
+
+    # get the locked list object
+    try:
+        mlist = MailList.MailList(listname)
+    except Errors.MMListError, e:
+        print _('No such list: %(listname)s')
+        sys.exit(1)
+
+    try:
+        # Get the list of addresses currently subscribed
+        addrs = {}
+        needsadding = {}
+        matches = {}
+        for addr in mlist.getMemberCPAddresses(mlist.getMembers()):
+            addrs[addr.lower()] = addr
+
+        for name, addr in filemembers:
+            # Any address found in the file that is also in the list can be
+            # ignored.  If not found in the list, it must be added later.
+            laddr = addr.lower()
+            if addrs.has_key(laddr):
+                del addrs[laddr]
+                matches[laddr] = 1
+            elif not matches.has_key(laddr):
+                needsadding[laddr] = (name, addr)
+
+        if not needsadding and not addrs:
+            print _('Nothing to do.')
+            sys.exit(0)
+
+        # addrs contains now all the addresses that need removing
+        for laddr, (name, addr) in needsadding.items():
+            pw = Utils.MakeRandomPassword()
+            # should not already be subscribed, otherwise our test above is
+            # broken.  Bogosity is if the address is listed in the file more
+            # than once.  Second and subsequent ones trigger an
+            # MMAlreadyAMember error.  Just catch it and go on.
+            userdesc = UserDesc(addr, name, pw, digest)
+            try:
+                if not dryrun:
+                    mlist.ApprovedAddMember(userdesc, welcome, notifyadmin)
+                s = email.Utils.formataddr((name, addr)).encode(enc, 'replace')
+                print _('Added  : %(s)s')
+            except Errors.MMAlreadyAMember:
+                pass
+
+        for laddr, addr in addrs.items():
+            # Should be a member, otherwise our test above is broken
+            if not dryrun:
+                try:
+                    mlist.ApprovedDeleteMember(addr, admin_notif=notifyadmin,
+                                               userack=goodbye)
+                except Errors.NotAMemberError:
+                    # This can happen if the address is illegal (i.e. can't be
+                    # parsed by email.Utils.parseaddr()) but for legacy
+                    # reasons is in the database.  Use a lower level remove to
+                    # get rid of this member's entry
+                    mlist.removeMember(addr)
+            name = mlist.getMemberName(laddr) or ''
+            enc = sys.getdefaultencoding()
+            s = email.Utils.formataddr((name, addr)).encode(enc, 'replace')
+            print _('Removed: %(s)s')
+
+        mlist.Save()
+    finally:
+        mlist.Unlock()
+
+
+if __name__ == '__main__':
+    main()
diff --git a/bin/transcheck b/bin/transcheck
new file mode 100755
index 00000000..fbb0dcd8
--- /dev/null
+++ b/bin/transcheck
@@ -0,0 +1,405 @@
+#! @PYTHON@
+#
+# transcheck - (c) 2002 by Simone Piunno <pioppo@ferrara.linux.it>
+#
+# This program is free software; you can redistribute it and/or modify it
+# under the terms of the version 2.0 of the GNU General Public License as
+# published by the Free Software Foundation.
+#
+# 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.
+
+"""
+Check a given Mailman translation, making sure that variables and
+tags referenced in translation are the same variables and tags in
+the original templates and catalog.
+
+Usage:
+
+cd $MAILMAN_DIR
+%(program)s [-q] <lang>
+
+Where <lang> is your country code (e.g. 'it' for Italy) and -q is
+to ask for a brief summary.
+"""
+
+import sys
+import re
+import os
+import getopt
+
+import paths
+from Mailman.i18n import _
+
+program = sys.argv[0]
+
+
+
+def usage(code, msg=''):
+    if code:
+        fd = sys.stderr
+    else:
+        fd = sys.stdout
+    print >> fd, _(__doc__)
+    if msg:
+        print >> fd, msg
+    sys.exit(code)
+
+
+
+class TransChecker:
+    "check a translation comparing with the original string"
+    def __init__(self, regexp):
+        self.dict = {}
+        self.errs = []
+        self.regexp = re.compile(regexp)
+
+    def checkin(self, string):
+        "scan a string from the original file"
+        for key in self.regexp.findall(string):
+            if self.dict.has_key(key):
+                self.dict[key] += 1
+            else:
+                self.dict[key] = 1
+
+    def checkout(self, string):
+        "scan a translated string"
+        for key in self.regexp.findall(string):
+            if self.dict.has_key(key):
+                self.dict[key] -= 1
+            else:
+                self.errs.append(
+                    "%(key)s was not found" %
+                    { 'key' : key }
+                )
+
+    def computeErrors(self):
+        "check for differences between checked in and checked out"
+        for key in self.dict.keys():
+            if self.dict[key] < 0:
+                self.errs.append(
+                    "Too much %(key)s" %
+                    { 'key'  : key }
+                )
+            if self.dict[key] > 0:
+                self.errs.append(
+                    "Too few %(key)s" %
+                    { 'key'  : key }
+                )
+        return self.errs
+
+    def status(self):
+        if self.errs:
+            return "FAILED"
+        else:
+            return "OK"
+
+    def errorsAsString(self):
+        msg = ""
+        for err in self.errs:
+            msg += " - %(err)s" % { 'err': err }
+        return msg
+
+    def reset(self):
+        self.dict = {}
+        self.errs = []
+
+
+
+class POParser:
+    "parse a .po file extracting msgids and msgstrs"
+    def __init__(self, filename=""):
+        self.status = 0
+        self.files = []
+        self.msgid = ""
+        self.msgstr = ""
+        self.line = 1
+        self.f = None
+        self.esc = { "n": "\n", "r": "\r", "t": "\t" }
+        if filename:
+            self.f = open(filename)
+
+    def open(self, filename):
+        self.f = open(filename)
+
+    def close(self):
+        self.f.close()
+
+    def parse(self):
+        """States table for the finite-states-machine parser:
+            0  idle
+            1  filename-or-comment
+            2  msgid
+            3  msgstr
+            4  end
+        """
+        # each time we can safely re-initialize those vars
+        self.files = []
+        self.msgid = ""
+        self.msgstr = ""
+
+
+        # can't continue if status == 4, this is a dead status
+        if self.status == 4:
+            return 0
+
+        while 1:
+            # continue scanning, char-by-char
+            c = self.f.read(1)
+            if not c:
+                # EOF -> maybe we have a msgstr to save?
+                self.status = 4
+                if self.msgstr:
+                    return 1
+                else:
+                    return 0
+
+            # keep the line count up-to-date
+            if c == "\n":
+                self.line += 1
+
+            # a pound was detected the previous char...
+            if self.status == 1:
+                if c == ":":
+                    # was a line of filenames
+                    row = self.f.readline()
+                    self.files += row.split()
+                    self.line += 1
+                elif c == "\n":
+                    # was a single pount on the line
+                    pass
+                else:
+                    # was a comment... discard
+                    self.f.readline()
+                    self.line += 1
+                # in every case, we switch to idle status
+                self.status = 0;
+                continue
+
+            # in idle status we search for a '#' or for a 'm'
+            if self.status == 0:
+                if   c == "#":
+                    # this could be a comment or a filename
+                    self.status = 1;
+                    continue
+                elif c == "m":
+                    # this should be a msgid start...
+                    s = self.f.read(4)
+                    assert s == "sgid"
+                    # so now we search for a '"'
+                    self.status = 2
+                    continue
+                # in idle only those other chars are possibile
+                assert c in [ "\n", " ", "\t" ]
+
+            # searching for the msgid string
+            if self.status == 2:
+                if c == "\n":
+                    # a double LF is not possible here
+                    c = self.f.read(1)
+                    assert c != "\n"
+                if c == "\"":
+                    # ok, this is the start of the string,
+                    # now search for the end
+                    while 1:
+                        c = self.f.read(1)
+                        if not c:
+                            # EOF, bailout
+                            self.status = 4
+                            return 0
+                        if c == "\\":
+                            # a quoted char...
+                            c = self.f.read(1)
+                            if self.esc.has_key(c):
+                                self.msgid += self.esc[c]
+                            else:
+                                self.msgid += c
+                            continue
+                        if c == "\"":
+                            # end of string found
+                            break
+                        # a normal char, add it
+                        self.msgid += c
+                if c == "m":
+                    # this should be a msgstr identifier
+                    s = self.f.read(5)
+                    assert s == "sgstr"
+                    # ok, now search for the msgstr string
+                    self.status = 3
+
+            # searching for the msgstr string
+            if self.status == 3:
+                if c == "\n":
+                    # a double LF is the end of the msgstr!
+                    c = self.f.read(1)
+                    if c == "\n":
+                        # ok, time to go idle and return
+                        self.status = 0
+                        self.line += 1
+                        return 1
+                if c == "\"":
+                    # start of string found
+                    while 1:
+                        c = self.f.read(1)
+                        if not c:
+                            # EOF, bail out
+                            self.status = 4
+                            return 1
+                        if c == "\\":
+                            # a quoted char...
+                            c = self.f.read(1)
+                            if self.esc.has_key(c):
+                                self.msgid += self.esc[c]
+                            else:
+                                self.msgid += c
+                            continue
+                        if c == "\"":
+                            # end of string
+                            break
+                        # a normal char, add it
+                        self.msgstr += c
+
+
+
+
+def check_file(translatedFile, originalFile, html=0, quiet=0):
+    """check a translated template against the original one
+       search also <MM-*> tags if html is not zero"""
+
+    if html:
+        c = TransChecker("(%\([^)]+\)[0-9]*[sd]|</?MM-[^>]+>)")
+    else:
+        c = TransChecker("(%\([^)]+\)[0-9]*[sd])")
+
+    try:
+        f = open(originalFile)
+    except IOError:
+        if not quiet:
+            print " - Can'open original file " + originalFile
+        return 1
+
+    while 1:
+        line = f.readline()
+        if not line: break
+        c.checkin(line)
+
+    f.close()
+
+    try:
+        f = open(translatedFile)
+    except IOError:
+        if not quiet:
+            print " - Can'open translated file " + translatedFile
+        return 1
+
+    while 1:
+        line = f.readline()
+        if not line: break
+        c.checkout(line)
+
+    f.close()
+
+    n = 0
+    msg = ""
+    for desc in c.computeErrors():
+        n +=1
+        if not quiet:
+            print " - %(desc)s" % { 'desc': desc }
+    return n
+
+
+
+def check_po(file, quiet=0):
+    "scan the po file comparing msgids with msgstrs"
+    n = 0
+    p = POParser(file)
+    c = TransChecker("(%\([^)]+\)[0-9]*[sdu]|%[0-9]*[sdu])")
+    while p.parse():
+        if p.msgstr:
+            c.reset()
+            c.checkin(p.msgid)
+            c.checkout(p.msgstr)
+            for desc in c.computeErrors():
+                n += 1
+                if not quiet:
+                    print " - near line %(line)d %(file)s: %(desc)s" % {
+                        'line': p.line,
+                        'file': p.files,
+                        'desc': desc
+                    }
+    p.close()
+    return n
+
+
+def main():
+    try:
+        opts, args = getopt.getopt(sys.argv[1:], 'qh', ['quiet', 'help'])
+    except getopt.error, msg:
+        usage(1, msg)
+
+    quiet = 0
+    for opt, arg in opts:
+        if opt in ('-h', '--help'):
+            usage(0)
+        elif opt in ('-q', '--quiet'):
+            quiet = 1
+
+    if len(args) <> 1:
+        usage(1)
+
+    lang = args[0]
+
+    isHtml = re.compile("\.html$");
+    isTxt = re.compile("\.txt$");
+
+    numerrors = 0
+    numfiles = 0
+    try:
+        files = os.listdir("templates/" + lang + "/")
+    except:
+        print "can't open templates/%s/" % lang
+    for file in files:
+        fileEN = "templates/en/" + file
+        fileIT = "templates/" + lang + "/" + file
+        errlist = []
+        if isHtml.search(file):
+            if not quiet:
+                print "HTML checking " + fileIT + "... "
+            n = check_file(fileIT, fileEN, html=1, quiet=quiet)
+            if n:
+                numerrors += n
+                numfiles += 1
+        elif isTxt.search(file):
+            if not quiet:
+                print "TXT  checking " + fileIT + "... "
+            n = check_file(fileIT, fileEN, html=0, quiet=quiet)
+            if n:
+                numerrors += n
+                numfiles += 1
+
+        else:
+            continue
+
+    file = "messages/" + lang + "/LC_MESSAGES/mailman.po"
+    if not quiet:
+        print "PO   checking " + file + "... "
+    n = check_po(file, quiet=quiet)
+    if n:
+        numerrors += n
+        numfiles += 1
+
+    if quiet:
+        print "%(errs)u warnings in %(files)u files" % {
+            'errs':  numerrors,
+            'files': numfiles
+        }
+
+
+if __name__ == '__main__':
+    main()
diff --git a/bin/unshunt b/bin/unshunt
new file mode 100644
index 00000000..cd8a538e
--- /dev/null
+++ b/bin/unshunt
@@ -0,0 +1,87 @@
+#! @PYTHON@
+
+# Copyright (C) 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.
+
+"""Move a message from the shunt queue to the original queue.
+
+Usage: %(PROGRAM)s [options] [directory]
+
+Where:
+
+    -h / --help
+        Print help and exit.
+
+Optional `directory' specifies a directory to dequeue from other than
+qfiles/shunt.
+"""
+
+import sys
+import getopt
+
+import paths
+from Mailman import mm_cfg
+from Mailman.Queue.sbcache import get_switchboard
+from Mailman.i18n import _
+
+
+
+def usage(code, msg=''):
+    if code:
+        fd = sys.stderr
+    else:
+        fd = sys.stdout
+    print >> fd, _(__doc__)
+    if msg:
+        print >> fd, msg
+    sys.exit(code)
+
+
+
+def main():
+    try:
+        opts, args = getopt.getopt(sys.argv[1:], 'h', ['help'])
+    except getopt.error, msg:
+        usage(1, msg)
+
+    for opt, arg in opts:
+        if opt in ('-h', '--help'):
+            usage(0)
+
+    if len(args) == 0:
+        qdir = mm_cfg.SHUNTQUEUE_DIR
+    elif len(args) == 1:
+        qdir = args[0]
+    else:
+        usage(1)
+
+    sb = get_switchboard(qdir)
+    for filebase in sb.files():
+        try:
+            msg, msgdata = sb.dequeue(filebase)
+            whichq = msgdata.get('whichq', mm_cfg.INQUEUE_DIR)
+            tosb = get_switchboard(whichq)
+            tosb.enqueue(msg, msgdata)
+        except Exception, e:
+            # If there are any unshunting errors, log them and continue trying
+            # other shunted messages.
+            print >> sys.stderr, _(
+                'Cannot unshunt message %(filebase)s, skipping:\n%(e)s')
+
+
+
+if __name__ == '__main__':
+    main()
diff --git a/bin/update b/bin/update
new file mode 100755
index 00000000..b0b425d3
--- /dev/null
+++ b/bin/update
@@ -0,0 +1,588 @@
+#! @PYTHON@
+#
+# 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.
+
+"""Perform all necessary upgrades.
+
+Usage: %(PROGRAM)s [options]
+
+Options:
+    -f/--force
+        Force running the upgrade procedures.  Normally, if the version number
+        of the installed Mailman matches the current version number (or a
+        `downgrade' is detected), nothing will be done.
+
+    -h/--help
+        Print this text and exit.
+
+Use this script to help you update to the latest release of Mailman from
+some previous version.  It knows about versions back to 1.0b4 (?).
+"""
+
+import os
+import md5
+import sys
+import time
+import errno
+import getopt
+import shutil
+import marshal
+
+import paths
+from Mailman import mm_cfg
+from Mailman import Utils
+from Mailman import MailList
+from Mailman.LockFile import TimeOutError
+from Mailman.i18n import _
+from Mailman.Queue.Switchboard import Switchboard
+from Mailman.OldStyleMemberships import OldStyleMemberships
+from Mailman.MemberAdaptor import BYBOUNCE, ENABLED
+
+FRESH = 0
+NOTFRESH = -1
+
+LMVFILE = os.path.join(mm_cfg.DATA_DIR, 'last_mailman_version')
+PROGRAM = sys.argv[0]
+
+
+
+def calcversions():
+    # Returns a tuple of (lastversion, thisversion).  If the last version
+    # could not be determined, lastversion will be FRESH or NOTFRESH,
+    # depending on whether this installation appears to be fresh or not.  The
+    # determining factor is whether there are files in the $var_prefix/logs
+    # subdir or not.  The version numbers are HEX_VERSIONs.
+    #
+    # See if we stored the last updated version
+    lastversion = None
+    thisversion = mm_cfg.HEX_VERSION
+    try:
+        fp = open(LMVFILE)
+        data = fp.read()
+        fp.close()
+        lastversion = int(data, 16)
+    except (IOError, ValueError):
+        pass
+    #
+    # try to figure out if this is a fresh install
+    if lastversion is None:
+        lastversion = FRESH
+        try:
+            if os.listdir(mm_cfg.LOG_DIR):
+                lastversion = NOTFRESH
+        except OSError:
+            pass
+    return (lastversion, thisversion)
+
+
+
+def makeabs(relpath):
+    return os.path.join(mm_cfg.PREFIX, relpath)
+
+def make_varabs(relpath):
+    return os.path.join(mm_cfg.VAR_PREFIX, relpath)
+
+
+def move_language_templates(mlist):
+    listname = mlist.internal_name()
+    print _('Fixing language templates: %(listname)s')
+    # Mailman 2.1 has a new cascading search for its templates, defined and
+    # described in Utils.py:maketext().  Putting templates in the top level
+    # templates/ subdir or the lists/<listname> subdir is deprecated and no
+    # longer searched..
+    #
+    # What this means is that most templates can live in the global templates/
+    # subdirectory, and only needs to be copied into the list-, vhost-, or
+    # site-specific language directories when needed.
+    #
+    # Also, by default all standard (i.e. English) templates must now live in
+    # the templates/en directory.  This update cleans up all the templates,
+    # deleting more-specific duplicates (as calculated by md5 checksums) in
+    # favor of more-global locations.
+    #
+    # First, get rid of any lists/<list> template or lists/<list>/en template
+    # that is identical to the global templates/* default.
+    for gtemplate in os.listdir(os.path.join(mm_cfg.TEMPLATE_DIR, 'en')):
+        # BAW: get rid of old templates, e.g. admlogin.txt and
+        # handle_opts.html
+        try:
+            fp = open(os.path.join(mm_cfg.TEMPLATE_DIR, gtemplate))
+        except IOError, e:
+            if e.errno <> errno.ENOENT: raise
+            # No global template
+            continue
+
+        gcksum = md5.new(fp.read()).digest()
+        fp.close()
+        # Match against the lists/<list>/* template
+        try:
+            fp = open(os.path.join(mlist.fullpath(), gtemplate))
+        except IOError, e:
+            if e.errno <> errno.ENOENT: raise
+        else:
+            tcksum = md5.new(fp.read()).digest()
+            fp.close()
+            if gcksum == tcksum:
+                os.unlink(os.path.join(mlist.fullpath(), gtemplate))
+        # Match against the lists/<list>/*.prev template
+        try:
+            fp = open(os.path.join(mlist.fullpath(), gtemplate + '.prev'))
+        except IOError, e:
+            if e.errno <> errno.ENOENT: raise
+        else:
+            tcksum = md5.new(fp.read()).digest()
+            fp.close()
+            if gcksum == tcksum:
+                os.unlink(os.path.join(mlist.fullpath(), gtemplate + '.prev'))
+        # Match against the lists/<list>/en/* templates
+        try:
+            fp = open(os.path.join(mlist.fullpath(), 'en', gtemplate))
+        except IOError, e:
+            if e.errno <> errno.ENOENT: raise
+        else:
+            tcksum = md5.new(fp.read()).digest()
+            fp.close()
+            if gcksum == tcksum:
+                os.unlink(os.path.join(mlist.fullpath(), 'en', gtemplate))
+        # Match against the templates/* template
+        try:
+            fp = open(os.path.join(mm_cfg.TEMPLATE_DIR, gtemplate))
+        except IOError, e:
+            if e.errno <> errno.ENOENT: raise
+        else:
+            tcksum = md5.new(fp.read()).digest()
+            fp.close()
+            if gcksum == tcksum:
+                os.unlink(os.path.join(mm_cfg.TEMPLATE_DIR, gtemplate))
+        # Match against the templates/*.prev template
+        try:
+            fp = open(os.path.join(mm_cfg.TEMPLATE_DIR, gtemplate + '.prev'))
+        except IOError, e:
+            if e.errno <> errno.ENOENT: raise
+        else:
+            tcksum = md5.new(fp.read()).digest()
+            fp.close()
+            if gcksum == tcksum:
+                os.unlink(os.path.join(mm_cfg.TEMPLATE_DIR,
+                                       gtemplate + '.prev'))
+
+
+
+def dolist(listname):
+    errors = 0
+    mlist = MailList.MailList(listname, lock=0)
+    try:
+        mlist.Lock(0.5)
+    except TimeOutError:
+        print >> sys.stderr, _('WARNING: could not acquire lock for list: '
+                               '%(listname)s')
+        return 1
+
+    # Sanity check the invariant that every BYBOUNCE disabled member must have
+    # bounce information.  Some earlier betas broke this.  BAW: we're
+    # submerging below the MemberAdaptor interface, so skip this if we're not
+    # using OldStyleMemberships.
+    if isinstance(mlist._memberadaptor, OldStyleMemberships):
+        noinfo = {}
+        for addr, (reason, when) in mlist.delivery_status.items():
+            if reason == BYBOUNCE and not mlist.bounce_info.has_key(addr):
+                noinfo[addr] = reason, when
+        # What to do about these folks with a BYBOUNCE delivery status and no
+        # bounce info?  This number should be very small, and I think it's
+        # fine to simple re-enable them and let the bounce machinery
+        # re-disable them if necessary.
+        n = len(noinfo)
+        if n > 0:
+            print _(
+                'Resetting %(n)s BYBOUNCEs disabled addrs with no bounce info')
+            for addr in noinfo.keys():
+                mlist.setDeliveryStatus(addr, ENABLED)
+
+    # Update the held requests database
+    print _("""Updating the held requests database.""")
+    mlist._UpdateRecords()
+
+    mbox_dir = make_varabs('archives/private/%s.mbox' % (listname))
+    mbox_file = make_varabs('archives/private/%s.mbox/%s' % (listname,
+                                                             listname))
+
+    o_pub_mbox_file = make_varabs('archives/public/%s' % (listname))
+    o_pri_mbox_file = make_varabs('archives/private/%s' % (listname))
+
+    html_dir = o_pri_mbox_file
+    o_html_dir = makeabs('public_html/archives/%s' % (listname))
+    #
+    # make the mbox directory if it's not there.
+    #
+    if not os.path.exists(mbox_dir):
+        ou = os.umask(0)
+        os.mkdir(mbox_dir, 02775)
+        os.umask(ou)
+    else:
+        # this shouldn't happen, but hey, just in case
+        if not os.path.isdir(mbox_dir):
+            print _("""\
+For some reason, %(mbox_dir)s exists as a file.  This won't work with
+b6, so I'm renaming it to %(mbox_dir)s.tmp and proceeding.""")
+            os.rename(mbox_dir, "%s.tmp" % (mbox_dir))
+            ou = os.umask(0)
+            os.mkdir(mbox_dir, 02775)
+            os.umask(ou)
+
+    # Move any existing mboxes around, but watch out for both a public and a
+    # private one existing
+    if os.path.isfile(o_pri_mbox_file) and os.path.isfile(o_pub_mbox_file):
+        if mlist.archive_private:
+            print _("""\
+
+%(listname)s has both public and private mbox archives.  Since this list
+currently uses private archiving, I'm installing the private mbox archive
+-- %(o_pri_mbox_file)s -- as the active archive, and renaming
+        %(o_pub_mbox_file)s
+to
+        %(o_pub_mbox_file)s.preb6
+
+You can integrate that into the archives if you want by using the 'arch'
+script.
+""") % (mlist._internal_name, o_pri_mbox_file, o_pub_mbox_file,
+        o_pub_mbox_file)
+            os.rename(o_pub_mbox_file, "%s.preb6" % (o_pub_mbox_file))
+        else:
+            print _("""\
+%s has both public and private mbox archives.  Since this list
+currently uses public archiving, I'm installing the public mbox file
+archive file (%s) as the active one, and renaming
+        %s
+    to
+        %s.preb6
+
+You can integrate that into the archives if you want by using the 'arch'
+script.
+""") % (mlist._internal_name, o_pub_mbox_file, o_pri_mbox_file,
+        o_pri_mbox_file)
+            os.rename(o_pri_mbox_file, "%s.preb6" % (o_pri_mbox_file))
+    #
+    # move private archive mbox there if it's around
+    # and take into account all sorts of absurdities
+    #
+    print _('- updating old private mbox file')
+    if os.path.exists(o_pri_mbox_file):
+        if os.path.isfile(o_pri_mbox_file):
+            os.rename(o_pri_mbox_file, mbox_file)
+        elif not os.path.isdir(o_pri_mbox_file):
+            newname = "%s.mm_install-dunno_what_this_was_but_its_in_the_way" \
+                      % o_pri_mbox_file
+            os.rename(o_pri_mbox_file, newname)
+            print _("""\
+    unknown file in the way, moving
+        %(o_pri_mbox_file)s
+    to
+        %(newname)s""")
+        else:
+            # directory
+            print _("""\
+    looks like you have a really recent CVS installation...
+    you're either one brave soul, or you already ran me""")
+
+
+    #
+    # move public archive mbox there if it's around
+    # and take into account all sorts of absurdities.
+    #
+    print _('- updating old public mbox file')
+    if os.path.exists(o_pub_mbox_file):
+        if os.path.isfile(o_pub_mbox_file):
+            os.rename(o_pub_mbox_file, mbox_file)
+        elif not os.path.isdir(o_pub_mbox_file):
+            newname = "%s.mm_install-dunno_what_this_was_but_its_in_the_way" \
+                      % o_pub_mbox_file
+            os.rename(o_pub_mbox_file, newname)
+            print _("""\
+    unknown file in the way, moving
+        %(o_pub_mbox_file)s
+    to
+        %(newname)s""")
+        else: # directory
+            print _("""\
+    looks like you have a really recent CVS installation...
+    you're either one brave soul, or you already ran me""")
+
+    #
+    # move the html archives there
+    #
+    if os.path.isdir(o_html_dir):
+        os.rename(o_html_dir, html_dir)
+        #
+        # chmod the html archives
+        #
+        os.chmod(html_dir, 02775)
+    # BAW: Is this still necessary?!
+    mlist.Save()
+    #
+    # check to see if pre-b4 list-specific templates are around
+    # and move them to the new place if there's not already
+    # a new one there
+    #
+    tmpl_dir = os.path.join(mm_cfg.PREFIX, "templates")
+    list_dir = os.path.join(mm_cfg.PREFIX, "lists")
+    b4_tmpl_dir = os.path.join(tmpl_dir, mlist._internal_name)
+    new_tmpl_dir = os.path.join(list_dir, mlist._internal_name)
+    if os.path.exists(b4_tmpl_dir):
+        print _("""\
+- This list looks like it might have <= b4 list templates around""")
+        for f in os.listdir(b4_tmpl_dir):
+            o_tmpl = os.path.join(b4_tmpl_dir, f)
+            n_tmpl = os.path.join(new_tmpl_dir, f)
+            if not os.path.exists(n_tmpl):
+                os.rename(o_tmpl, n_tmpl)
+                print _('- moved %(o_tmpl)s to %(n_tmpl)s')
+            else:
+                print _("""\
+- both %(o_tmpl)s and %(n_tmpl)s exist, leaving untouched""")
+    #
+    # Move all the templates to the en language subdirectory as required for
+    # Mailman 2.1
+    #
+    move_language_templates(mlist)
+    # Avoid eating filehandles with the list lockfiles
+    mlist.Unlock()
+    return 0
+
+
+
+def archive_path_fixer(unused_arg, dir, files):
+    # Passed to os.path.walk to fix the perms on old html archives.
+    for f in files:
+        abs = os.path.join(dir, f)
+        if os.path.isdir(abs):
+            if f == "database":
+                os.chmod(abs, 02770)
+            else:
+                os.chmod(abs, 02775)
+        elif os.path.isfile(abs):
+            os.chmod(abs, 0664)
+
+def remove_old_sources(module):
+    # Also removes old directories.
+    src = '%s/%s' % (mm_cfg.PREFIX, module)
+    pyc = src + "c"
+    if os.path.isdir(src):
+        print _('removing directory %(src)s and everything underneath')
+        shutil.rmtree(src)
+    elif os.path.exists(src):
+        print _('removing %(src)s')
+        try:
+            os.unlink(src)
+        except os.error, rest:
+            print _("Warning: couldn't remove %(src)s -- %(rest)s")
+    if module.endswith('.py') and os.path.exists(pyc):
+        try:
+            os.unlink(pyc)
+        except os.error, rest:
+            print _("couldn't remove old file %(pyc)s -- %(rest)s")
+
+
+def update_qfiles():
+    print _('updating old qfiles')
+    prefix = `time.time()` + '+'
+    # Be sure the qfiles/in directory exists (we don't really need the
+    # switchboard object, but it's convenient for creating the directory).
+    sb = Switchboard(mm_cfg.INQUEUE_DIR)
+    for file in os.listdir(mm_cfg.QUEUE_DIR):
+        # Updating means just mokving the .db and .msg files to qfiles/in where
+        # it should be dequeued, converted, and processed normally.
+        if file.endswith('.msg'):
+            oldmsgfile = os.path.join(mm_cfg.QUEUE_DIR, file)
+            newmsgfile = os.path.join(mm_cfg.INQUEUE_DIR, prefix + file)
+            os.rename(oldmsgfile, newmsgfile)
+        elif file.endswith('.db'):
+            olddbfile = os.path.join(mm_cfg.QUEUE_DIR, file)
+            newdbfile = os.path.join(mm_cfg.INQUEUE_DIR, prefix + file)
+            os.rename(olddbfile, newdbfile)
+
+
+
+def main():
+    errors = 0
+    # get rid of old stuff
+    print _('getting rid of old source files')
+    for mod in ('Mailman/Archiver.py', 'Mailman/HyperArch.py',
+                'Mailman/HyperDatabase.py', 'Mailman/pipermail.py',
+                'Mailman/smtplib.py', 'Mailman/Cookie.py',
+                'bin/update_to_10b6', 'scripts/mailcmd',
+                'scripts/mailowner', 'mail/wrapper', 'Mailman/pythonlib',
+                'cgi-bin/archives', 'Mailman/MailCommandHandler'):
+        remove_old_sources(mod)
+    listnames = Utils.list_names()
+    if not listnames:
+        print _('no lists == nothing to do, exiting')
+        return
+    #
+    # for people with web archiving, make sure the directories
+    # in the archiving are set with proper perms for b6.
+    #
+    if os.path.isdir("%s/public_html/archives" % mm_cfg.PREFIX):
+        print _("""\
+fixing all the perms on your old html archives to work with b6
+If your archives are big, this could take a minute or two...""")
+        os.path.walk("%s/public_html/archives" % mm_cfg.PREFIX,
+                     archive_path_fixer, "")
+        print _('done')
+    for listname in listnames:
+        print _('Updating mailing list: %(listname)s')
+        errors = errors + dolist(listname)
+        print
+    print _('Updating Usenet watermarks')
+    wmfile = os.path.join(mm_cfg.DATA_DIR, 'gate_watermarks')
+    try:
+        fp = open(wmfile)
+    except IOError:
+        print _('- nothing to update here')
+    else:
+        d = marshal.load(fp)
+        fp.close()
+        for listname in d.keys():
+            if listname not in listnames:
+                # this list no longer exists
+                continue
+            mlist = MailList.MailList(listname, lock=0)
+            try:
+                mlist.Lock(0.5)
+            except TimeOutError:
+                print >> sys.stderr, _(
+                    'WARNING: could not acquire lock for list: %(listname)s')
+                errors = errors + 1
+            else:
+                # Pre 1.0b7 stored 0 in the gate_watermarks file to indicate
+                # that no gating had been done yet.  Without coercing this to
+                # None, the list could now suddenly get flooded.
+                mlist.usenet_watermark = d[listname] or None
+                mlist.Save()
+                mlist.Unlock()
+        os.unlink(wmfile)
+        print _('- usenet watermarks updated and gate_watermarks removed')
+    #
+    # In Mailman 2.1, the pending database format and file name has changed.
+    #
+    oldpendingfile = os.path.join(mm_cfg.DATA_DIR, 'pending_subscriptions.db')
+    try:
+        fp = open(oldpendingfile)
+    except IOError, e:
+        if e.errno <> errno.ENOENT: raise
+    else:
+        print _('Updating old pending_subscriptions.db database')
+        from Mailman import Pending
+        db = marshal.load(fp)
+        Pending._update(db)
+        fp.close()
+        os.unlink(oldpendingfile)
+    #
+    # In Mailman 2.1, the qfiles directory has a different structure and a
+    # different content.
+    #
+    update_qfiles()
+    #
+    # This warning was necessary for the upgrade from 1.0b9 to 1.0b10.
+    # There's no good way of figuring this out for releases prior to 2.0beta2
+    # :(
+    #
+    if lastversion == NOTFRESH:
+        print _("""
+
+NOTE NOTE NOTE NOTE NOTE
+
+    You are upgrading an existing Mailman installation, but I can't tell what
+    version you were previously running.
+
+    If you are upgrading from Mailman 1.0b9 or earlier you will need to
+    manually update your mailing lists.  For each mailing list you need to
+    copy the file templates/options.html lists/<listname>/options.html.
+
+    However, if you have edited this file via the Web interface, you will have
+    to merge your changes into this file, otherwise you will lose your
+    changes.
+
+NOTE NOTE NOTE NOTE NOTE
+
+""")
+    return errors
+
+
+
+def usage(code, msg=''):
+    if code:
+        fd = sys.stderr
+    else:
+        fd = sys.stdout
+    print >> fd, _(__doc__) % globals()
+    if msg:
+        print >> sys.stderr, msg
+    sys.exit(code)
+
+
+
+if __name__ == '__main__':
+    try:
+        opts, args = getopt.getopt(sys.argv[1:], 'hf',
+                                   ['help', 'force'])
+    except getopt.error, msg:
+        usage(1, msg)
+
+    if args:
+        usage(1, 'Unexpected arguments: %s' % args)
+
+    force = 0
+    for opt, arg in opts:
+        if opt in ('-h', '--help'):
+            usage(0)
+        elif opt in ('-f', '--force'):
+            force = 1
+
+    # calculate the versions
+    lastversion, thisversion = calcversions()
+    hexlversion = hex(lastversion)
+    hextversion = hex(thisversion)
+    if lastversion == thisversion and not force:
+        # nothing to do
+        print _('No updates are necessary.')
+        sys.exit(0)
+    if lastversion > thisversion and not force:
+        print _("""\
+Downgrade detected, from version %(hexlversion)s to version %(hextversion)s
+This is probably not safe.
+Exiting.""")
+        sys.exit(1)
+    print _('Upgrading from version %(hexlversion)s to %(hextversion)s')
+    errors = main()
+    if not errors:
+        # Record the version we just upgraded to
+        fp = open(LMVFILE, 'w')
+        fp.write(hex(mm_cfg.HEX_VERSION) + '\n')
+        fp.close()
+    else:
+        lockdir = mm_cfg.LOCK_DIR
+        print _('''\
+
+ERROR:
+
+The locks for some lists could not be acquired.  This means that either
+Mailman was still active when you upgraded, or there were stale locks in the
+%(lockdir)s directory.
+
+You must put Mailman into a quiescent state and remove all stale locks, then
+re-run "make update" manually.  See the INSTALL and UPGRADE files for details.
+''')
diff --git a/bin/version b/bin/version
new file mode 100644
index 00000000..6e10e869
--- /dev/null
+++ b/bin/version
@@ -0,0 +1,26 @@
+#! @PYTHON@
+#
+# 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.
+
+"""Print the Mailman version.
+"""
+
+import paths
+import Mailman.mm_cfg
+from Mailman.i18n import _
+
+print _('Using Mailman version:'), Mailman.mm_cfg.VERSION
diff --git a/bin/withlist b/bin/withlist
new file mode 100644
index 00000000..a9bd6361
--- /dev/null
+++ b/bin/withlist
@@ -0,0 +1,275 @@
+#! @PYTHON@
+#
+# 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.
+
+"""General framework for interacting with a mailing list object.
+
+There are two ways to use this script: interactively or programmatically.
+Using it interactively allows you to play with, examine and modify a MailList
+object from Python's interactive interpreter.  When running interactively, a
+MailList object called `m' will be available in the global namespace.  It also
+loads the class MailList into the global namespace.
+
+Programmatically, you can write a function to operate on a MailList object,
+and this script will take care of the housekeeping (see below for examples).
+In that case, the general usage syntax is:
+
+%% bin/withlist [options] listname [args ...]
+
+Options:
+
+    -l / --lock
+        Lock the list when opening.  Normally the list is opened unlocked
+        (e.g. for read-only operations).  You can always lock the file after
+        the fact by typing `m.Lock()'
+
+        Note that if you use this option, you should explicitly call m.Save()
+        before exiting, since the interpreter's clean up procedure will not
+        automatically save changes to the MailList object (but it will unlock
+        the list).
+
+    -i / --interactive
+        Leaves you at an interactive prompt after all other processing is
+        complete.  This is the default unless the -r option is given.
+
+    --run [module.]callable
+    -r [module.]callable
+        This can be used to run a script with the opened MailList object.
+        This works by attempting to import `module' (which must already be
+        accessible on your sys.path), and then calling `callable' from the
+        module.  callable can be a class or function; it is called with the
+        MailList object as the first argument.  If additional args are given
+        on the command line, they are passed as subsequent positional args to
+        the callable.
+
+        Note that `module.' is optional; if it is omitted then a module with
+        the name `callable' will be imported.
+
+        The global variable `r' will be set to the results of this call.
+
+    --all / -a
+        This option only works with the -r option.  Use this if you want to
+        execute the script on all mailing lists.  When you use -a you should
+        not include a listname argument on the command line.  The variable `r'
+        will be a list of all the results.
+
+    --quiet / -q
+        Suppress all status messages.
+
+    --help / -h
+        Print this message and exit
+
+
+Here's an example of how to use the -r option.  Say you have a file in the
+Mailman installation directory called `listaddr.py', with the following
+two functions:
+
+def listaddr(mlist):
+    print mlist.GetListEmail()
+
+def requestaddr(mlist):
+    print mlist.GetRequestEmail()
+
+Now, from the command line you can print the list's posting address by running
+the following from the command line:
+
+%% bin/withlist -r listaddr mylist
+Loading list: mylist (unlocked)
+Importing listaddr ...
+Running listaddr.listaddr() ...
+mylist@myhost.com
+
+And you can print the list's request address by running:
+
+%% bin/withlist -r listaddr.requestaddr mylist
+Loading list: mylist (unlocked)
+Importing listaddr ...
+Running listaddr.requestaddr() ...
+mylist-request@myhost.com
+
+As another example, say you wanted to change the password for a particular
+user on a particular list.  You could put the following function in a file
+called `changepw.py':
+
+from Mailman.Errors import NotAMember
+
+def changepw(mlist, addr, newpasswd):
+    try:
+        mlist.setMemberPassword(addr, newpasswd)
+        mlist.Save()
+    except NotAMember:
+        print 'No address matched:', addr
+
+and run this from the command line:
+%% bin/withlist -l -r changepw mylist somebody@somewhere.org foobar
+"""
+
+import sys
+import getopt
+import code
+
+import paths
+from Mailman import Utils
+from Mailman import MailList
+from Mailman import Errors
+from Mailman.i18n import _
+
+# `m' will be the MailList object and `r' will be the results of the callable
+m = None
+r = None
+VERBOSE = 1
+LOCK = 0
+
+
+
+def usage(code, msg=''):
+    if code:
+        fd = sys.stderr
+    else:
+        fd = sys.stdout
+    print >> fd, _(__doc__)
+    if msg:
+        print >> fd, msg
+    sys.exit(code)
+
+
+def atexit():
+    """Unlock a locked list, but do not implicitly Save() it.
+
+    This does not get run if the interpreter exits because of a signal, or if
+    os._exit() is called.  It will get called if an exception occurs though.
+    """
+    global m
+    if not m:
+        return
+    if m.Locked():
+        if VERBOSE:
+            listname = m.internal_name()
+            print >> sys.stderr, _(
+                'Unlocking (but not saving) list: %(listname)s')
+        m.Unlock()
+    if VERBOSE:
+        print >> sys.stderr, _('Finalizing')
+    del m
+
+
+
+def do_list(listname, args, func):
+    global m
+    # first try to open mailing list
+    if VERBOSE:
+        print >> sys.stderr, _('Loading list %(listname)s'),
+        if LOCK:
+            print >> sys.stderr, _('(locked)')
+        else:
+            print >> sys.stderr, _('(unlocked)')
+
+    try:
+        m = MailList.MailList(listname, lock=LOCK)
+    except Errors.MMUnknownListError:
+        print >> sys.stderr, _('Unknown list: %(listname)s')
+        m = None
+
+    # try to import the module and run the callable
+    if func:
+        return func(m, *args)
+    return None
+
+
+
+def main():
+    global VERBOSE
+    global LOCK
+    global r
+    try:
+        opts, args = getopt.getopt(
+            sys.argv[1:], 'hlr:qia',
+            ['help', 'lock', 'run=', 'quiet', 'interactive', 'all'])
+    except getopt.error, msg:
+        usage(1, msg)
+
+    run = None
+    interact = None
+    all = 0
+    for opt, arg in opts:
+        if opt in ('-h', '--help'):
+            usage(0)
+        elif opt in ('-l', '--lock'):
+            LOCK = 1
+        elif opt in ('-r', '--run'):
+            run = arg
+        elif opt in ('-q', '--quiet'):
+            VERBOSE = 0
+        elif opt in ('-i', '--interactive'):
+            interact = 1
+        elif opt in ('-a', '--all'):
+            all = 1
+
+    if len(args) < 1 and not all:
+        usage(1, _('No list name supplied.'))
+
+    if all and not run:
+        usage(1, _('--all requires --run'))
+
+    # The default for interact is 1 unless -r was given
+    if interact is None:
+        if run is None:
+            interact = 1
+        else:
+            interact = 0
+
+    # try to import the module for the callable
+    func = None
+    if run:
+        i = run.find('.')
+        if i < 0:
+            module = run
+            callable = run
+        else:
+            module = run[:i]
+            callable = run[i+1:]
+        if VERBOSE:
+            print >> sys.stderr, _('Importing %(module)s...')
+        mod = __import__(module)
+        if VERBOSE:
+            print >> sys.stderr, _('Running %(module)s.%(callable)s()...')
+        func = getattr(mod, callable)
+
+    if all:
+        r = [do_list(listname, args, func) for listname in Utils.list_names()]
+    else:
+        listname = args.pop(0).lower().strip()
+        r = do_list(listname, args, func)
+
+    # Now go to interactive mode, perhaps
+    if interact:
+        # Attempt to import the readline module, so we emulate the interactive
+        # console as closely as possible.  Don't worry if it doesn't import.
+        # readline works by side-effect.
+        try:
+            import readline
+        except ImportError:
+            pass
+        namespace = globals().copy()
+        namespace.update(locals())
+        code.InteractiveConsole(namespace).interact(
+            _("The variable `m' is the %(listname)s MailList instance"))
+
+
+
+sys.exitfunc = atexit
+main()