home *** CD-ROM | disk | FTP | other *** search
/ PC World 2001 April / PCWorld_2001-04_cd.bin / Software / TemaCD / webclean / !!!python!!! / BeOpen-Python-2.0.exe / MIMETOOLS.PY < prev    next >
Encoding:
Python Source  |  2000-09-30  |  5.7 KB  |  230 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 encoding in ('7bit', '8bit'):
  144.         return output.write(input.read())
  145.     if decodetab.has_key(encoding):
  146.         pipethrough(input, decodetab[encoding], output)
  147.     else:
  148.         raise ValueError, \
  149.               'unknown Content-Transfer-Encoding: %s' % encoding
  150.  
  151. def encode(input, output, encoding):
  152.     """Encode common content-transfer-encodings (base64, quopri, uuencode)."""
  153.     if encoding == 'base64':
  154.         import base64
  155.         return base64.encode(input, output)
  156.     if encoding == 'quoted-printable':
  157.         import quopri
  158.         return quopri.encode(input, output, 0)
  159.     if encoding in ('uuencode', 'x-uuencode', 'uue', 'x-uue'):
  160.         import uu
  161.         return uu.encode(input, output)
  162.     if encoding in ('7bit', '8bit'):
  163.         return output.write(input.read())
  164.     if encodetab.has_key(encoding):
  165.         pipethrough(input, encodetab[encoding], output)
  166.     else:
  167.         raise ValueError, \
  168.               'unknown Content-Transfer-Encoding: %s' % encoding
  169.  
  170. # The following is no longer used for standard encodings
  171.  
  172. # XXX This requires that uudecode and mmencode are in $PATH
  173.  
  174. uudecode_pipe = '''(
  175. TEMP=/tmp/@uu.$$
  176. sed "s%^begin [0-7][0-7]* .*%begin 600 $TEMP%" | uudecode
  177. cat $TEMP
  178. rm $TEMP
  179. )'''
  180.  
  181. decodetab = {
  182.     'uuencode':        uudecode_pipe,
  183.     'x-uuencode':        uudecode_pipe,
  184.     'uue':            uudecode_pipe,
  185.     'x-uue':        uudecode_pipe,
  186.     'quoted-printable':    'mmencode -u -q',
  187.     'base64':        'mmencode -u -b',
  188. }
  189.  
  190. encodetab = {
  191.     'x-uuencode':        'uuencode tempfile',
  192.     'uuencode':        'uuencode tempfile',
  193.     'x-uue':        'uuencode tempfile',
  194.     'uue':            'uuencode tempfile',
  195.     'quoted-printable':    'mmencode -q',
  196.     'base64':        'mmencode -b',
  197. }
  198.  
  199. def pipeto(input, command):
  200.     pipe = os.popen(command, 'w')
  201.     copyliteral(input, pipe)
  202.     pipe.close()
  203.  
  204. def pipethrough(input, command, output):
  205.     tempname = tempfile.mktemp()
  206.     try:
  207.         temp = open(tempname, 'w')
  208.     except IOError:
  209.         print '*** Cannot create temp file', `tempname`
  210.         return
  211.     copyliteral(input, temp)
  212.     temp.close()
  213.     pipe = os.popen(command + ' <' + tempname, 'r')
  214.     copybinary(pipe, output)
  215.     pipe.close()
  216.     os.unlink(tempname)
  217.  
  218. def copyliteral(input, output):
  219.     while 1:
  220.         line = input.readline()
  221.         if not line: break
  222.         output.write(line)
  223.  
  224. def copybinary(input, output):
  225.     BUFSIZE = 8192
  226.     while 1:
  227.         line = input.read(BUFSIZE)
  228.         if not line: break
  229.         output.write(line)
  230.