~mailman-coders/mailman/2.1

# Copyright (C) 1998-2018 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,

# USA.

"""Process and produce the list-administration options forms."""

# For Python 2.1.x compatibility

from __future__ import nested_scopes

import sys

import os

import re

import cgi

import urllib

import signal

from types import *

from email.Utils import unquote, parseaddr, formataddr

from Mailman import mm_cfg

from Mailman import Utils

from Mailman import Message

from Mailman import MailList

from Mailman import Errors

from Mailman import MemberAdaptor

from Mailman import i18n

from Mailman.UserDesc import UserDesc

from Mailman.htmlformat import *

from Mailman.Cgi import Auth

from Mailman.Logging.Syslog import syslog

from Mailman.Utils import sha_new

from Mailman.CSRFcheck import csrf_check

# Set up i18n

_ = i18n._

i18n.set_language(mm_cfg.DEFAULT_SERVER_LANGUAGE)

def D_(s):

    return s

NL = '\n'

OPTCOLUMNS = 11

try:

    True, False

except NameError:

    True = 1

    False = 0

AUTH_CONTEXTS = (mm_cfg.AuthListAdmin, mm_cfg.AuthSiteAdmin)

def main():

    # Try to find out which list is being administered

    parts = Utils.GetPathPieces()

    if not parts:

        # None, so just do the admin overview and be done with it

        admin_overview()

        return

    # Get the list object

    listname = parts[0].lower()

    try:

        mlist = MailList.MailList(listname, lock=0)

    except Errors.MMListError, e:

        # Avoid cross-site scripting attacks

        safelistname = Utils.websafe(listname)

        # Send this with a 404 status.

        print 'Status: 404 Not Found'

        admin_overview(_('No such list <em>%(safelistname)s</em>'))

        syslog('error', 'admin: No such list "%s": %s\n',

               listname, e)

        return

    # Now that we know what list has been requested, all subsequent admin

    # pages are shown in that list's preferred language.

    i18n.set_language(mlist.preferred_language)

    # If the user is not authenticated, we're done.

    cgidata = cgi.FieldStorage(keep_blank_values=1)

    try:

        cgidata.getfirst('csrf_token', '')

    except TypeError:

        # Someone crafted a POST with a bad Content-Type:.

        doc = Document()

        doc.set_language(mm_cfg.DEFAULT_SERVER_LANGUAGE)

        doc.AddItem(Header(2, _("Error")))

        doc.AddItem(Bold(_('Invalid options to CGI script.')))

        # Send this with a 400 status.

        print 'Status: 400 Bad Request'

        print doc.Format()

        return

    # CSRF check

    safe_params = ['VARHELP', 'adminpw', 'admlogin',

                   'letter', 'chunk', 'findmember',

                   'legend']

    params = cgidata.keys()

    if set(params) - set(safe_params):

        csrf_checked = csrf_check(mlist, cgidata.getfirst('csrf_token'),

                                  'admin')

    else:

        csrf_checked = True

    # if password is present, void cookie to force password authentication.

    if cgidata.getfirst('adminpw'):

        os.environ['HTTP_COOKIE'] = ''

        csrf_checked = True

    if not mlist.WebAuthenticate((mm_cfg.AuthListAdmin,

                                  mm_cfg.AuthSiteAdmin),

                                 cgidata.getfirst('adminpw', '')):

        if cgidata.has_key('adminpw'):

            # This is a re-authorization attempt

            msg = Bold(FontSize('+1', _('Authorization failed.'))).Format()

            remote = os.environ.get('HTTP_FORWARDED_FOR',

                     os.environ.get('HTTP_X_FORWARDED_FOR',

                     os.environ.get('REMOTE_ADDR',

                                    'unidentified origin')))

            syslog('security',

                   'Authorization failed (admin): list=%s: remote=%s',

                   listname, remote)

        else:

            msg = ''

        Auth.loginpage(mlist, 'admin', msg=msg)

        return

    # Which subcategory was requested?  Default is `general'

    if len(parts) == 1:

        category = 'general'

        subcat = None

    elif len(parts) == 2:

        category = parts[1]

        subcat = None

    else:

        category = parts[1]

        subcat = parts[2]

    # Is this a log-out request?

    if category == 'logout':

        # site-wide admin should also be able to logout.

        if mlist.AuthContextInfo(mm_cfg.AuthSiteAdmin)[0] == 'site':

            print mlist.ZapCookie(mm_cfg.AuthSiteAdmin)

        print mlist.ZapCookie(mm_cfg.AuthListAdmin)

        Auth.loginpage(mlist, 'admin', frontpage=1)

        return

    # Sanity check

    if category not in mlist.GetConfigCategories().keys():

        category = 'general'

    # Is the request for variable details?

    varhelp = None

    qsenviron = os.environ.get('QUERY_STRING')

    parsedqs = None

    if qsenviron:

        parsedqs = cgi.parse_qs(qsenviron)

    if cgidata.has_key('VARHELP'):

        varhelp = cgidata.getfirst('VARHELP')

    elif parsedqs:

        # POST methods, even if their actions have a query string, don't get

        # put into FieldStorage's keys :-(

        qs = parsedqs.get('VARHELP')

        if qs and isinstance(qs, ListType):

            varhelp = qs[0]

    if varhelp:

        option_help(mlist, varhelp)

        return

    # The html page document

    doc = Document()

    doc.set_language(mlist.preferred_language)

    # From this point on, the MailList object must be locked.  However, we

    # must release the lock no matter how we exit.  try/finally isn't enough,

    # because of this scenario: user hits the admin page which may take a long

    # time to render; user gets bored and hits the browser's STOP button;

    # browser shuts down socket; server tries to write to broken socket and

    # gets a SIGPIPE.  Under Apache 1.3/mod_cgi, Apache catches this SIGPIPE

    # (I presume it is buffering output from the cgi script), then turns

    # around and SIGTERMs the cgi process.  Apache waits three seconds and

    # then SIGKILLs the cgi process.  We /must/ catch the SIGTERM and do the

    # most reasonable thing we can in as short a time period as possible.  If

    # we get the SIGKILL we're screwed (because it's uncatchable and we'll

    # have no opportunity to clean up after ourselves).

    #

    # This signal handler catches the SIGTERM, unlocks the list, and then

    # exits the process.  The effect of this is that the changes made to the

    # MailList object will be aborted, which seems like the only sensible

    # semantics.

    #

    # BAW: This may not be portable to other web servers or cgi execution

    # models.

    def sigterm_handler(signum, frame, mlist=mlist):

        # Make sure the list gets unlocked...

        mlist.Unlock()

        # ...and ensure we exit, otherwise race conditions could cause us to

        # enter MailList.Save() while we're in the unlocked state, and that

        # could be bad!

        sys.exit(0)

    mlist.Lock()

    try:

        # Install the emergency shutdown signal handler

        signal.signal(signal.SIGTERM, sigterm_handler)

        if cgidata.keys():

            if csrf_checked:

                # There are options to change

                change_options(mlist, category, subcat, cgidata, doc)

            else:

                doc.addError(

                  _('The form lifetime has expired. (request forgery check)'))

            # Let the list sanity check the changed values

            mlist.CheckValues()

        # Additional sanity checks

        if not mlist.digestable and not mlist.nondigestable:

            doc.addError(

                _('''You have turned off delivery of both digest and

                non-digest messages.  This is an incompatible state of

                affairs.  You must turn on either digest delivery or

                non-digest delivery or your mailing list will basically be

                unusable.'''), tag=_('Warning: '))

        dm = mlist.getDigestMemberKeys()

        if not mlist.digestable and dm:

            doc.addError(

                _('''You have digest members, but digests are turned

                off. Those people will not receive mail.

                Affected member(s) %(dm)r.'''),

                tag=_('Warning: '))

        rm = mlist.getRegularMemberKeys()

        if not mlist.nondigestable and rm:

            doc.addError(

                _('''You have regular list members but non-digestified mail is

                turned off.  They will receive non-digestified mail until you

                fix this problem. Affected member(s) %(rm)r.'''),

                tag=_('Warning: '))

        # Glom up the results page and print it out

        show_results(mlist, doc, category, subcat, cgidata)

        print doc.Format()

        mlist.Save()

    finally:

        # Now be sure to unlock the list.  It's okay if we get a signal here

        # because essentially, the signal handler will do the same thing.  And

        # unlocking is unconditional, so it's not an error if we unlock while

        # we're already unlocked.

        mlist.Unlock()

def admin_overview(msg=''):

    # Show the administrative overview page, with the list of all the lists on

    # this host.  msg is an optional error message to display at the top of

    # the page.

    #

    # This page should be displayed in the server's default language, which

    # should have already been set.

    hostname = Utils.get_domain()

    legend = _('%(hostname)s mailing lists - Admin Links')

    # The html `document'

    doc = Document()

    doc.set_language(mm_cfg.DEFAULT_SERVER_LANGUAGE)

    doc.SetTitle(legend)

    # The table that will hold everything

    table = Table(border=0, width="100%")

    table.AddRow([Center(Header(2, legend))])

    table.AddCellInfo(table.GetCurrentRowIndex(), 0, colspan=2,

                      bgcolor=mm_cfg.WEB_HEADER_COLOR)

    # Skip any mailing list that isn't advertised.

    advertised = []

    listnames = Utils.list_names()

    listnames.sort()

    for name in listnames:

        try:

            mlist = MailList.MailList(name, lock=0)

        except Errors.MMUnknownListError:

            # The list could have been deleted by another process.

            continue

        if mlist.advertised:

            if mm_cfg.VIRTUAL_HOST_OVERVIEW and (

                   mlist.web_page_url.find('/%s/' % hostname) == -1 and

                   mlist.web_page_url.find('/%s:' % hostname) == -1):

                # List is for different identity of this host - skip it.

                continue

            else:

                advertised.append((mlist.GetScriptURL('admin'),

                                   mlist.real_name,

                                   Utils.websafe(mlist.GetDescription())))

    # Greeting depends on whether there was an error or not

    if msg:

        greeting = FontAttr(msg, color="ff5060", size="+1")

    else:

        greeting = FontAttr(_('Welcome!'), size='+2')

    welcome = []

    mailmanlink = Link(mm_cfg.MAILMAN_URL, _('Mailman')).Format()

    if not advertised:

        welcome.extend([

            greeting,

            _('''<p>There currently are no publicly-advertised %(mailmanlink)s

            mailing lists on %(hostname)s.'''),

            ])

    else:

        welcome.extend([

            greeting,

            _('''<p>Below is the collection of publicly-advertised

            %(mailmanlink)s mailing lists on %(hostname)s.  Click on a list

            name to visit the configuration pages for that list.'''),

            ])

    creatorurl = Utils.ScriptURL('create')

    mailman_owner = Utils.get_site_email()

    extra = msg and _('right ') or ''

    welcome.extend([

        _('''To visit the administrators configuration page for an

        unadvertised list, open a URL similar to this one, but with a '/' and

        the %(extra)slist name appended.  If you have the proper authority,

        you can also <a href="%(creatorurl)s">create a new mailing list</a>.

        <p>General list information can be found at '''),

        Link(Utils.ScriptURL('listinfo'),

             _('the mailing list overview page')),

        '.',

        _('<p>(Send questions and comments to '),

        Link('mailto:%s' % mailman_owner, mailman_owner),

        '.)<p>',

        ])

    table.AddRow([Container(*welcome)])

    table.AddCellInfo(max(table.GetCurrentRowIndex(), 0), 0, colspan=2)

    if advertised:

        table.AddRow([' ', ' '])

        table.AddRow([Bold(FontAttr(_('List'), size='+2')),

                      Bold(FontAttr(_('Description'), size='+2'))

                      ])

        highlight = 1

        for url, real_name, description in advertised:

            table.AddRow(

                [Link(url, Bold(real_name)),

                      description or Italic(_('[no description available]'))])

            if highlight and mm_cfg.WEB_HIGHLIGHT_COLOR:

                table.AddRowInfo(table.GetCurrentRowIndex(),

                                 bgcolor=mm_cfg.WEB_HIGHLIGHT_COLOR)

            highlight = not highlight

    doc.AddItem(table)

    doc.AddItem('<hr>')

    doc.AddItem(MailmanLogo())

    print doc.Format()

def option_help(mlist, varhelp):

    # The html page document

    doc = Document()

    doc.set_language(mlist.preferred_language)

    # Find out which category and variable help is being requested for.

    item = None

    reflist = varhelp.split('/')

    if len(reflist) >= 2:

        category = subcat = None

        if len(reflist) == 2:

            category, varname = reflist

        elif len(reflist) == 3:

            category, subcat, varname = reflist

        options = mlist.GetConfigInfo(category, subcat)

        if options:

            for i in options:

                if i and i[0] == varname:

                    item = i

                    break

    # Print an error message if we couldn't find a valid one

    if not item:

        bad = _('No valid variable name found.')

        doc.addError(bad)

        doc.AddItem(mlist.GetMailmanFooter())

        print doc.Format()

        return

    # Get the details about the variable

    varname, kind, params, dependancies, description, elaboration = \

             get_item_characteristics(item)

    # Set up the document

    realname = mlist.real_name

    legend = _("""%(realname)s Mailing list Configuration Help

    <br><em>%(varname)s</em> Option""")

    header = Table(width='100%')

    header.AddRow([Center(Header(3, legend))])

    header.AddCellInfo(header.GetCurrentRowIndex(), 0, colspan=2,

                       bgcolor=mm_cfg.WEB_HEADER_COLOR)

    doc.SetTitle(_("Mailman %(varname)s List Option Help"))

    doc.AddItem(header)

    doc.AddItem("<b>%s</b> (%s): %s<p>" % (varname, category, description))

    if elaboration:

        doc.AddItem("%s<p>" % elaboration)

    if subcat:

        url = '%s/%s/%s' % (mlist.GetScriptURL('admin'), category, subcat)

    else:

        url = '%s/%s' % (mlist.GetScriptURL('admin'), category)

    form = Form(url, mlist=mlist, contexts=AUTH_CONTEXTS)

    valtab = Table(cellspacing=3, cellpadding=4, width='100%')

    add_options_table_item(mlist, category, subcat, valtab, item, detailsp=0)

    form.AddItem(valtab)

    form.AddItem('<p>')

    form.AddItem(Center(submit_button()))

    doc.AddItem(Center(form))

    doc.AddItem(_("""<em><strong>Warning:</strong> changing this option here

    could cause other screens to be out-of-sync.  Be sure to reload any other

    pages that are displaying this option for this mailing list.  You can also

    """))

    adminurl = mlist.GetScriptURL('admin')

    if subcat:

        url = '%s/%s/%s' % (adminurl, category, subcat)

    else:

        url = '%s/%s' % (adminurl, category)

    categoryname = mlist.GetConfigCategories()[category][0]

    doc.AddItem(Link(url, _('return to the %(categoryname)s options page.')))

    doc.AddItem('</em>')

    doc.AddItem(mlist.GetMailmanFooter())

    print doc.Format()

def show_results(mlist, doc, category, subcat, cgidata):

    # Produce the results page

    adminurl = mlist.GetScriptURL('admin')

    categories = mlist.GetConfigCategories()

    label = _(categories[category][0])

    # Set up the document's headers

    realname = mlist.real_name

    doc.SetTitle(_('%(realname)s Administration (%(label)s)'))

    doc.AddItem(Center(Header(2, _(

        '%(realname)s mailing list administration<br>%(label)s Section'))))

    doc.AddItem('<hr>')

    # Now we need to craft the form that will be submitted, which will contain

    # all the variable settings, etc.  This is a bit of a kludge because we

    # know that the autoreply and members categories supports file uploads.

    encoding = None

    if category in ('autoreply', 'members'):

        encoding = 'multipart/form-data'

    if subcat:

        form = Form('%s/%s/%s' % (adminurl, category, subcat),

                    encoding=encoding, mlist=mlist, contexts=AUTH_CONTEXTS)

    else:

        form = Form('%s/%s' % (adminurl, category),

                    encoding=encoding, mlist=mlist, contexts=AUTH_CONTEXTS)

    # This holds the two columns of links

    linktable = Table(valign='top', width='100%')

    linktable.AddRow([Center(Bold(_("Configuration Categories"))),

                      Center(Bold(_("Other Administrative Activities")))])

    # The `other links' are stuff in the right column.

    otherlinks = UnorderedList()

    otherlinks.AddItem(Link(mlist.GetScriptURL('admindb'),

                            _('Tend to pending moderator requests')))

    otherlinks.AddItem(Link(mlist.GetScriptURL('listinfo'),

                            _('Go to the general list information page')))

    otherlinks.AddItem(Link(mlist.GetScriptURL('edithtml'),

                            _('Edit the public HTML pages and text files')))

    otherlinks.AddItem(Link(mlist.GetBaseArchiveURL(),

                            _('Go to list archives')).Format() +

                       '<br>&nbsp;<br>')

    # We do not allow through-the-web deletion of the site list!

    if mm_cfg.OWNERS_CAN_DELETE_THEIR_OWN_LISTS and \

           mlist.internal_name() <> mm_cfg.MAILMAN_SITE_LIST:

        otherlinks.AddItem(Link(mlist.GetScriptURL('rmlist'),

                                _('Delete this mailing list')).Format() +

                           _(' (requires confirmation)<br>&nbsp;<br>'))

    otherlinks.AddItem(Link('%s/logout' % adminurl,

                            # BAW: What I really want is a blank line, but

                            # adding an   won't do it because of the

                            # bullet added to the list item.

                            '<FONT SIZE="+2"><b>%s</b></FONT>' %

                            _('Logout')))

    # These are links to other categories and live in the left column

    categorylinks_1 = categorylinks = UnorderedList()

    categorylinks_2 = ''

    categorykeys = categories.keys()

    half = len(categorykeys) / 2

    counter = 0

    subcat = None

    for k in categorykeys:

        label = _(categories[k][0])

        url = '%s/%s' % (adminurl, k)

        if k == category:

            # Handle subcategories

            subcats = mlist.GetConfigSubCategories(k)

            if subcats:

                subcat = Utils.GetPathPieces()[-1]

                for k, v in subcats:

                    if k == subcat:

                        break

                else:

                    # The first subcategory in the list is the default

                    subcat = subcats[0][0]

                subcat_items = []

                for sub, text in subcats:

                    if sub == subcat:

                        text = Bold('[%s]' % text).Format()

                    subcat_items.append(Link(url + '/' + sub, text))

                categorylinks.AddItem(

                    Bold(label).Format() +

                    UnorderedList(*subcat_items).Format())

            else:

                categorylinks.AddItem(Link(url, Bold('[%s]' % label)))

        else:

            categorylinks.AddItem(Link(url, label))

        counter += 1

        if counter >= half:

            categorylinks_2 = categorylinks = UnorderedList()

            counter = -len(categorykeys)

    # Make the emergency stop switch a rude solo light

    etable = Table()

    # Add all the links to the links table...

    etable.AddRow([categorylinks_1, categorylinks_2])

    etable.AddRowInfo(etable.GetCurrentRowIndex(), valign='top')

    if mlist.emergency:

        label = _('Emergency moderation of all list traffic is enabled')

        etable.AddRow([Center(

            Link('?VARHELP=general/emergency', Bold(label)))])

        color = mm_cfg.WEB_ERROR_COLOR

        etable.AddCellInfo(etable.GetCurrentRowIndex(), 0,

                           colspan=2, bgcolor=color)

    linktable.AddRow([etable, otherlinks])

    # ...and add the links table to the document.

    form.AddItem(linktable)

    form.AddItem('<hr>')

    form.AddItem(

        _('''Make your changes in the following section, then submit them

        using the <em>Submit Your Changes</em> button below.''')

        + '<p>')

    # The members and passwords categories are special in that they aren't

    # defined in terms of gui elements.  Create those pages here.

    if category == 'members':

        # Figure out which subcategory we should display

        subcat = Utils.GetPathPieces()[-1]

        if subcat not in ('list', 'add', 'remove', 'change', 'sync'):

            subcat = 'list'

        # Add member category specific tables

        form.AddItem(membership_options(mlist, subcat, cgidata, doc, form))

        form.AddItem(Center(submit_button('setmemberopts_btn')))

        # In "list" subcategory, we can also search for members

        if subcat == 'list':

            form.AddItem('<hr>\n')

            table = Table(width='100%')

            table.AddRow([Center(Header(2, _('Additional Member Tasks')))])

            table.AddCellInfo(table.GetCurrentRowIndex(), 0, colspan=2,

                              bgcolor=mm_cfg.WEB_HEADER_COLOR)

            # Add a blank separator row

            table.AddRow([' ', ' '])

            # Add a section to set the moderation bit for all members

            table.AddRow([_("""<li>Set everyone's moderation bit, including

            those members not currently visible""")])

            table.AddCellInfo(table.GetCurrentRowIndex(), 0, colspan=2)

            table.AddRow([RadioButtonArray('allmodbit_val',

                                           (_('Off'), _('On')),

                                           mlist.default_member_moderation),

                          SubmitButton('allmodbit_btn', _('Set'))])

            form.AddItem(table)

    elif category == 'passwords':

        form.AddItem(Center(password_inputs(mlist)))

        form.AddItem(Center(submit_button()))

    else:

        form.AddItem(show_variables(mlist, category, subcat, cgidata, doc))

        form.AddItem(Center(submit_button()))

    # And add the form

    doc.AddItem(form)

    doc.AddItem(mlist.GetMailmanFooter())

def show_variables(mlist, category, subcat, cgidata, doc):

    options = mlist.GetConfigInfo(category, subcat)

    # The table containing the results

    table = Table(cellspacing=3, cellpadding=4, width='100%')

    # Get and portray the text label for the category.

    categories = mlist.GetConfigCategories()

    label = _(categories[category][0])

    table.AddRow([Center(Header(2, label))])

    table.AddCellInfo(table.GetCurrentRowIndex(), 0, colspan=2,

                      bgcolor=mm_cfg.WEB_HEADER_COLOR)

    # The very first item in the config info will be treated as a general

    # description if it is a string

    description = options[0]

    if isinstance(description, StringType):

        table.AddRow([description])

        table.AddCellInfo(table.GetCurrentRowIndex(), 0, colspan=2)

        options = options[1:]

    if not options:

        return table

    # Add the global column headers

    table.AddRow([Center(Bold(_('Description'))),

                  Center(Bold(_('Value')))])

    table.AddCellInfo(max(table.GetCurrentRowIndex(), 0), 0,

                      width='15%')

    table.AddCellInfo(max(table.GetCurrentRowIndex(), 0), 1,

                      width='85%')

    for item in options:

        if type(item) == StringType:

            # The very first banner option (string in an options list) is

            # treated as a general description, while any others are

            # treated as section headers - centered and italicized...

            table.AddRow([Center(Italic(item))])

            table.AddCellInfo(table.GetCurrentRowIndex(), 0, colspan=2)

        else:

            add_options_table_item(mlist, category, subcat, table, item)

    table.AddRow(['<br>'])

    table.AddCellInfo(table.GetCurrentRowIndex(), 0, colspan=2)

    return table

def add_options_table_item(mlist, category, subcat, table, item, detailsp=1):

    # Add a row to an options table with the item description and value.

    varname, kind, params, extra, descr, elaboration = \

             get_item_characteristics(item)

    if elaboration is None:

        elaboration = descr

    descr = get_item_gui_description(mlist, category, subcat,

                                     varname, descr, elaboration, detailsp)

    val = get_item_gui_value(mlist, category, kind, varname, params, extra)

    table.AddRow([descr, val])

    table.AddCellInfo(table.GetCurrentRowIndex(), 0,

                      bgcolor=mm_cfg.WEB_ADMINITEM_COLOR)

    table.AddCellInfo(table.GetCurrentRowIndex(), 1,

                      bgcolor=mm_cfg.WEB_ADMINITEM_COLOR)

def get_item_characteristics(record):

    # Break out the components of an item description from its description

    # record:

    #

    # 0 -- option-var name

    # 1 -- type

    # 2 -- entry size

    # 3 -- ?dependancies?

    # 4 -- Brief description

    # 5 -- Optional description elaboration

    if len(record) == 5:

        elaboration = None

        varname, kind, params, dependancies, descr = record

    elif len(record) == 6:

        varname, kind, params, dependancies, descr, elaboration = record

    else:

        raise ValueError, _('Badly formed options entry:\n %(record)s')

    return varname, kind, params, dependancies, descr, elaboration

def get_item_gui_value(mlist, category, kind, varname, params, extra):

    """Return a representation of an item's settings."""

    # Give the category a chance to return the value for the variable

    value = None

    label, gui = mlist.GetConfigCategories()[category]

    if hasattr(gui, 'getValue'):

        value = gui.getValue(mlist, kind, varname, params)

    # Filter out None, and volatile attributes

    if value is None and not varname.startswith('_'):

        value = getattr(mlist, varname)

    # Now create the widget for this value

    if kind == mm_cfg.Radio or kind == mm_cfg.Toggle:

        # If we are returning the option for subscribe policy and this site

        # doesn't allow open subscribes, then we have to alter the value of

        # mlist.subscribe_policy as passed to RadioButtonArray in order to

        # compensate for the fact that there is one fewer option.

        # Correspondingly, we alter the value back in the change options

        # function -scott

        #

        # TBD: this is an ugly ugly hack.

        if varname.startswith('_'):

            checked = 0

        else:

            checked = value