home *** CD-ROM | disk | FTP | other *** search
/ linuxmafia.com 2016 / linuxmafia.com.tar / linuxmafia.com / pub / palmos / pippy-0.6beta-src.tar.gz / pippy-0.6beta-src.tar / pippy-0.6beta-src / src / Lib / mimetools.py < prev    next >
Text File  |  2000-12-21  |  5KB  |  226 lines
  1. """Various tools used by MIME-reading or MIME-writing programs."""
  2.  
  3.  
  4. import os
  5. import rfc822
  6. import string
  7. import tempfile
  8.  
  9.  
  10. class Message(rfc822.Message):
  11.     """A derived class of rfc822.Message that knows about MIME headers and
  12.     contains some hooks for decoding encoded and multipart messages."""
  13.  
  14.     def __init__(self, fp, seekable = 1):
  15.         rfc822.Message.__init__(self, fp, seekable)
  16.         self.encodingheader = \
  17.             self.getheader('content-transfer-encoding')
  18.         self.typeheader = \
  19.             self.getheader('content-type')
  20.         self.parsetype()
  21.         self.parseplist()
  22.  
  23.     def parsetype(self):
  24.         str = self.typeheader
  25.         if str == None:
  26.             str = 'text/plain'
  27.         if ';' in str:
  28.             i = string.index(str, ';')
  29.             self.plisttext = str[i:]
  30.             str = str[:i]
  31.         else:
  32.             self.plisttext = ''
  33.         fields = string.splitfields(str, '/')
  34.         for i in range(len(fields)):
  35.             fields[i] = string.lower(string.strip(fields[i]))
  36.         self.type = string.joinfields(fields, '/')
  37.         self.maintype = fields[0]
  38.         self.subtype = string.joinfields(fields[1:], '/')
  39.  
  40.     def parseplist(self):
  41.         str = self.plisttext
  42.         self.plist = []
  43.         while str[:1] == ';':
  44.             str = str[1:]
  45.             if ';' in str:
  46.                 # XXX Should parse quotes!
  47.                 end = string.index(str, ';')
  48.             else:
  49.                 end = len(str)
  50.             f = str[:end]
  51.             if '=' in f:
  52.                 i = string.index(f, '=')
  53.                 f = string.lower(string.strip(f[:i])) + \
  54.                     '=' + string.strip(f[i+1:])
  55.             self.plist.append(string.strip(f))
  56.             str = str[end:]
  57.  
  58.     def getplist(self):
  59.         return self.plist
  60.  
  61.     def getparam(self, name):
  62.         name = string.lower(name) + '='
  63.         n = len(name)
  64.         for p in self.plist:
  65.             if p[:n] == name:
  66.                 return rfc822.unquote(p[n:])
  67.         return None
  68.  
  69.     def getparamnames(self):
  70.         result = []
  71.         for p in self.plist:
  72.             i = string.find(p, '=')
  73.             if i >= 0:
  74.                 result.append(string.lower(p[:i]))
  75.         return result
  76.  
  77.     def getencoding(self):
  78.         if self.encodingheader == None:
  79.             return '7bit'
  80.         return string.lower(self.encodingheader)
  81.  
  82.     def gettype(self):
  83.         return self.type
  84.  
  85.     def getmaintype(self):
  86.         return self.maintype
  87.  
  88.     def getsubtype(self):
  89.         return self.subtype
  90.  
  91.  
  92.  
  93.  
  94. # Utility functions
  95. # -----------------
  96.  
  97.  
  98. _prefix = None
  99.  
  100. def choose_boundary():
  101.     """Return a random string usable as a multipart boundary.
  102.     The method used is so that it is *very* unlikely that the same
  103.     string of characters will every occur again in the Universe,
  104.     so the caller needn't check the data it is packing for the
  105.     occurrence of the boundary.
  106.  
  107.     The boundary contains dots so you have to quote it in the header."""
  108.  
  109.     global _prefix
  110.     import time
  111.     import random
  112.     if _prefix == None:
  113.         import socket
  114.         import os
  115.         hostid = socket.gethostbyname(socket.gethostname())
  116.         try:
  117.             uid = `os.getuid()`
  118.         except:
  119.             uid = '1'
  120.         try:
  121.             pid = `os.getpid()`
  122.         except:
  123.             pid = '1'
  124.         _prefix = hostid + '.' + uid + '.' + pid
  125.     timestamp = '%.3f' % time.time()
  126.     seed = `random.randint(0, 32767)`
  127.     return _prefix + '.' + timestamp + '.' + seed
  128.  
  129.  
  130. # Subroutines for decoding some common content-transfer-types
  131.  
  132. def decode(input, output, encoding):
  133.     """Decode common content-transfer-encodings (base64, quopri, uuencode)."""
  134.     if encoding == 'base64':
  135.         import base64
  136.         return base64.decode(input, output)
  137.     if encoding == 'quoted-printable':
  138.         import quopri
  139.         return quopri.decode(input, output)
  140.     if encoding in ('uuencode', 'x-uuencode', 'uue', 'x-uue'):
  141.         import uu
  142.         return uu.decode(input, output)
  143.     if decodetab.has_key(encoding):
  144.         pipethrough(input, decodetab[encoding], output)
  145.     else:
  146.         raise ValueError, \
  147.               'unknown Content-Transfer-Encoding: %s' % encoding
  148.  
  149. def encode(input, output, encoding):
  150.     """Encode common content-transfer-encodings (base64, quopri, uuencode)."""
  151.     if encoding == 'base64':
  152.         import base64
  153.         return base64.encode(input, output)
  154.     if encoding == 'quoted-printable':
  155.         import quopri
  156.         return quopri.encode(input, output, 0)
  157.     if encoding in ('uuencode', 'x-uuencode', 'uue', 'x-uue'):
  158.         import uu
  159.         return uu.encode(input, output)
  160.     if encodetab.has_key(encoding):
  161.         pipethrough(input, encodetab[encoding], output)
  162.     else:
  163.         raise ValueError, \
  164.               'unknown Content-Transfer-Encoding: %s' % encoding
  165.  
  166. # The following is no longer used for standard encodings
  167.  
  168. # XXX This requires that uudecode and mmencode are in $PATH
  169.  
  170. uudecode_pipe = '''(
  171. TEMP=/tmp/@uu.$$
  172. sed "s%^begin [0-7][0-7]* .*%begin 600 $TEMP%" | uudecode
  173. cat $TEMP
  174. rm $TEMP
  175. )'''
  176.  
  177. decodetab = {
  178.     'uuencode':        uudecode_pipe,
  179.     'x-uuencode':        uudecode_pipe,
  180.     'uue':            uudecode_pipe,
  181.     'x-uue':        uudecode_pipe,
  182.     'quoted-printable':    'mmencode -u -q',
  183.     'base64':        'mmencode -u -b',
  184. }
  185.  
  186. encodetab = {
  187.     'x-uuencode':        'uuencode tempfile',
  188.     'uuencode':        'uuencode tempfile',
  189.     'x-uue':        'uuencode tempfile',
  190.     'uue':            'uuencode tempfile',
  191.     'quoted-printable':    'mmencode -q',
  192.     'base64':        'mmencode -b',
  193. }
  194.  
  195. def pipeto(input, command):
  196.     pipe = os.popen(command, 'w')
  197.     copyliteral(input, pipe)
  198.     pipe.close()
  199.  
  200. def pipethrough(input, command, output):
  201.     tempname = tempfile.mktemp()
  202.     try:
  203.         temp = open(tempname, 'w')
  204.     except IOError:
  205.         print '*** Cannot create temp file', `tempname`
  206.         return
  207.     copyliteral(input, temp)
  208.     temp.close()
  209.     pipe = os.popen(command + ' <' + tempname, 'r')
  210.     copybinary(pipe, output)
  211.     pipe.close()
  212.     os.unlink(tempname)
  213.  
  214. def copyliteral(input, output):
  215.     while 1:
  216.         line = input.readline()
  217.         if not line: break
  218.         output.write(line)
  219.  
  220. def copybinary(input, output):
  221.     BUFSIZE = 8192
  222.     while 1:
  223.         line = input.read(BUFSIZE)
  224.         if not line: break
  225.         output.write(line)
  226.