"""Mailcap file handling.  See RFC 1524.""" import os __all__ = ["getcaps","findmatch"] # Part 1: top-level interface. def getcaps():    """Return a dictionary containing the mailcap database.     The dictionary maps a MIME type (in all lowercase, e.g. 'text/plain')    to a list of dictionaries corresponding to mailcap entries.  The list    collects all the entries for that MIME type from all available mailcap    files.  Each dictionary contains key-value pairs for that MIME type,    where the viewing command is stored with the key "view".     """    caps = {}    for mailcap in listmailcapfiles():        try:            fp = open(mailcap, 'r')        except IOError:            continue        morecaps = readmailcapfile(fp)        fp.close()        for key, value in morecaps.iteritems():            if not key in caps:                caps[key] = value            else:                caps[key] = caps[key] + value    return caps def listmailcapfiles():    """Return a list of all mailcap files found on the system."""    # XXX Actually, this is Unix-specific    if 'MAILCAPS' in os.environ:        str = os.environ['MAILCAPS']        mailcaps = str.split(':')    else:        if 'HOME' in os.environ:            home = os.environ['HOME']        else:            # Don't bother with getpwuid()            home = '.' # Last resort        mailcaps = [home + '/.mailcap', '/etc/mailcap',                '/usr/etc/mailcap', '/usr/local/etc/mailcap']    return mailcaps  # Part 2: the parser. def readmailcapfile(fp):    """Read a mailcap file and return a dictionary keyed by MIME type.     Each MIME type is mapped to an entry consisting of a list of    dictionaries; the list will contain more than one such dictionary    if a given MIME type appears more than once in the mailcap file.    Each dictionary contains key-value pairs for that MIME type, where    the viewing command is stored with the key "view".    """    caps = {}    while 1:        line = fp.readline()        if not line: break        # Ignore comments and blank lines        if line[0] == '#' or line.strip() == '':            continue        nextline = line        # Join continuation lines        while nextline[-2:] == '\\\n':            nextline = fp.readline()            if not nextline: nextline = '\n'            line = line[:-2] + nextline        # Parse the line        key, fields = parseline(line)        if not (key and fields):            continue        # Normalize the key        types = key.split('/')        for j in range(len(types)):            types[j] = types[j].strip()        key = '/'.join(types).lower()        # Update the database        if key in caps:            caps[key].append(fields)        else:            caps[key] = [fields]    return caps def parseline(line):    """Parse one entry in a mailcap file and return a dictionary.     The viewing command is stored as the value with the key "view",    and the rest of the fields produce key-value pairs in the dict.    """    fields = []    i, n = 0, len(line)    while i < n:        field, i = parsefield(line, i, n)        fields.append(field)        i = i+1 # Skip semicolon    if len(fields) < 2:        return None, None    key, view, rest = fields[0], fields[1], fields[2:]    fields = {'view': view}    for field in rest:        i = field.find('=')        if i < 0:            fkey = field            fvalue = ""        else:            fkey = field[:i].strip()            fvalue = field[i+1:].strip()        if fkey in fields:            # Ignore it            pass        else:            fields[fkey] = fvalue    return key, fields def parsefield(line, i, n):    """Separate one key-value pair in a mailcap entry."""    start = i    while i < n:        c = line[i]        if c == ';':            break        elif c == '\\':            i = i+2        else:            i = i+1    return line[start:i].strip(), i  # Part 3: using the database. def findmatch(caps, MIMEtype, key='view', filename="/dev/null", plist=[]):    """Find a match for a mailcap entry.     Return a tuple containing the command line, and the mailcap entry    used; (None, None) if no match is found.  This may invoke the    'test' command of several matching entries before deciding which    entry to use.     """    entries = lookup(caps, MIMEtype, key)    # XXX This code should somehow check for the needsterminal flag.    for e in entries:        if 'test' in e:            test = subst(e['test'], filename, plist)            if test and os.system(test) != 0:                continue        command = subst(e[key], MIMEtype, filename, plist)        return command, e    return None, None def lookup(caps, MIMEtype, key=None):    entries = []    if MIMEtype in caps:        entries = entries + caps[MIMEtype]    MIMEtypes = MIMEtype.split('/')    MIMEtype = MIMEtypes[0] + '/*'    if MIMEtype in caps:        entries = entries + caps[MIMEtype]    if key is not None:        entries = filter(lambda e, key=key: key in e, entries)    return entries def subst(field, MIMEtype, filename, plist=[]):    # XXX Actually, this is Unix-specific    res = ''    i, n = 0, len(field)    while i < n:        c = field[i]; i = i+1        if c != '%':            if c == '\\':                c = field[i:i+1]; i = i+1            res = res + c        else:            c = field[i]; i = i+1            if c == '%':                res = res + c            elif c == 's':                res = res + filename            elif c == 't':                res = res + MIMEtype            elif c == '{':                start = i                while i < n and field[i] != '}':                    i = i+1                name = field[start:i]                i = i+1                res = res + findparam(name, plist)            # XXX To do:            # %n == number of parts if type is multipart/*            # %F == list of alternating type and filename for parts            else:                res = res + '%' + c    return res def findparam(name, plist):    name = name.lower() + '='    n = len(name)    for p in plist:        if p[:n].lower() == name:            return p[n:]    return ''  # Part 4: test program. def test():    import sys    caps = getcaps()    if not sys.argv[1:]:        show(caps)        return    for i in range(1, len(sys.argv), 2):        args = sys.argv[i:i+2]        if len(args) < 2:            print "usage: mailcap [MIMEtype file] ..."            return        MIMEtype = args[0]        file = args[1]        command, e = findmatch(caps, MIMEtype, 'view', file)        if not command:            print "No viewer found for", type        else:            print "Executing:", command            sts = os.system(command)            if sts:                print "Exit status:", sts def show(caps):    print "Mailcap files:"    for fn in listmailcapfiles(): print "\t" + fn    print    if not caps: caps = getcaps()    print "Mailcap entries:"    print    ckeys = caps.keys()    ckeys.sort()    for type in ckeys:        print type        entries = caps[type]        for e in entries:            keys = e.keys()            keys.sort()            for k in keys:                print "  %-15s" % k, e[k]            print if __name__ == '__main__':    test()