Lib/mailbox.py

   1 #! /usr/bin/env python
   2
   3 """Classes to handle Unix style, MMDF style, and MH style mailboxes."""
   4
   5
   6 import rfc822
   7 import os
   8
   9 class _Mailbox:
  10
  11         def __init__(self, fp):
  12                 self.fp = fp
  13                 self.seekp = 0
  14
  15         def seek(self, pos, whence=0):
  16                 if whence==1:           # Relative to current position
  17                         self.pos = self.pos + pos
  18                 if whence==2:           # Relative to file's end
  19                         self.pos = self.stop + pos
  20                 else:                   # Default - absolute position
  21                         self.pos = self.start + pos
  22
  23         def next(self):
  24                 while 1:
  25                         self.fp.seek(self.seekp)
  26                         try:
  27                                 self._search_start()
  28                         except EOFError:
  29                                 self.seekp = self.fp.tell()
  30                                 return None
  31                         start = self.fp.tell()
  32                         self._search_end()
  33                         self.seekp = stop = self.fp.tell()
  34                         if start <> stop:
  35                                 break
  36                 return rfc822.Message(_Subfile(self.fp, start, stop))
  37
  38 class _Subfile:
  39
  40         def __init__(self, fp, start, stop):
  41                 self.fp = fp
  42                 self.start = start
  43                 self.stop = stop
  44                 self.pos = self.start
  45
  46         def read(self, length = None):
  47                 if self.pos >= self.stop:
  48                         return ''
  49                 if length is None:
  50                         length = self.stop - self.pos
  51                 self.fp.seek(self.pos)
  52                 self.pos = self.pos + length
  53                 return self.fp.read(length)
  54
  55         def readline(self, length = None):
  56                 if self.pos >= self.stop:
  57                         return ''
  58                 if length is None:
  59                         length = self.stop - self.pos
  60                 self.fp.seek(self.pos)
  61                 data = self.fp.readline(length)
  62                 if len(data) < length:
  63                         length = len(data)
  64                 self.pos = self.pos + length
  65                 return data
  66
  67         def tell(self):
  68                 return self.pos - self.start
  69
  70         def seek(self, pos, whence=0):
  71                 if whence == 0:
  72                         self.pos = self.start + pos
  73                 elif whence == 1:
  74                         self.pos = self.pos + pos
  75                 elif whence == 2:
  76                         self.pos = self.stop + pos
  77
  78         def close(self):
  79                 pass
  80
  81 class UnixMailbox(_Mailbox):
  82
  83         def _search_start(self):
  84                 while 1:
  85                         line = self.fp.readline()
  86                         if not line:
  87                                 raise EOFError
  88                         if line[:5] == 'From ' and self._isrealfromline(line):
  89                                 return
  90
  91         def _search_end(self):
  92                 while 1:
  93                         pos = self.fp.tell()
  94                         line = self.fp.readline()
  95                         if not line:
  96                                 return
  97                         if line[:5] == 'From ' and self._isrealfromline(line):
  98                                 self.fp.seek(pos)
  99                                 return
 100
 101         # An overridable mechanism to test for From-line-ness.
 102         # You can either specify a different regular expression
 103         # or define a whole new _isrealfromline() method.
 104         # Note that this only gets called for lines starting with
 105         # the 5 characters "From ".
 106
 107         _fromlinepattern = r"From \s*[^\s]+\s+\w\w\w\s+\w\w\w\s+\d?\d\s+" \
 108                            r"\d?\d:\d\d:\d\d(\s+[^\s]+)?\s+\d\d\d\d\s*$"
 109         _regexp = None
 110
 111         def _isrealfromline(self, line):
 112                 if not self._regexp:
 113                         import re
 114                         self._regexp = re.compile(self._fromlinepattern)
 115                 return self._regexp.match(line)
 116
 117 class MmdfMailbox(_Mailbox):
 118
 119         def _search_start(self):
 120                 while 1:
 121                         line = self.fp.readline()
 122                         if not line:
 123                                 raise EOFError
 124                         if line[:5] == '\001\001\001\001\n':
 125                                 return
 126
 127         def _search_end(self):
 128                 while 1:
 129                         pos = self.fp.tell()
 130                         line = self.fp.readline()
 131                         if not line:
 132                                 return
 133                         if line == '\001\001\001\001\n':
 134                                 self.fp.seek(pos)
 135                                 return
 136
 137 class MHMailbox:
 138
 139         def __init__(self, dirname):
 140                 import re
 141                 pat = re.compile('^[0-9][0-9]*$')
 142                 self.dirname = dirname
 143                 files = os.listdir(self.dirname)
 144                 self.boxes = []
 145                 for f in files:
 146                         if pat.match(f):
 147                                 self.boxes.append(f)
 148
 149         def next(self):
 150                 if not self.boxes:
 151                         return None
 152                 fn = self.boxes[0]
 153                 del self.boxes[0]
 154                 fp = open(os.path.join(self.dirname, fn))
 155                 return rfc822.Message(fp)
 156
 157
 158 class BabylMailbox(_Mailbox):
 159
 160         def _search_start(self):
 161                 while 1:
 162                         line = self.fp.readline()
 163                         if not line:
 164                                 raise EOFError
 165                         if line == '*** EOOH ***\n':
 166                                 return
 167
 168         def _search_end(self):
 169                 while 1:
 170                         pos = self.fp.tell()
 171                         line = self.fp.readline()
 172                         if not line:
 173                                 return
 174                         if line == '\037\014\n':
 175                                 self.fp.seek(pos)
 176                                 return
 177
 178
 179 def _test():
 180         import time
 181         import sys
 182         import string
 183         import os
 184
 185         args = sys.argv[1:]
 186         if not args:
 187                 for key in 'MAIL', 'LOGNAME', 'USER':
 188                         if os.environ.has_key(key):
 189                                 mbox = os.environ[key]
 190                                 break
 191                 else:
 192                         print "$MAIL, $LOGNAME nor $USER set -- who are you?"
 193                         return
 194         else:
 195                 mbox = args[0]
 196         if mbox[:1] == '+':
 197                 mbox = os.environ['HOME'] + '/Mail/' + mbox[1:]
 198         elif not '/' in mbox:
 199                 mbox = '/usr/mail/' + mbox
 200         if os.path.isdir(mbox):
 201                 mb = MHMailbox(mbox)
 202         else:
 203                 fp = open(mbox, 'r')
 204                 mb = UnixMailbox(fp)
 205
 206         msgs = []
 207         while 1:
 208                 msg = mb.next()
 209                 if msg is None:
 210                         break
 211                 msgs.append(msg)
 212                 msg.fp = None
 213         if len(args) > 1:
 214                 num = string.atoi(args[1])
 215                 print 'Message %d body:'%num
 216                 msg = msgs[num-1]
 217                 msg.rewindbody()
 218                 sys.stdout.write(msg.fp.read())
 219         else:
 220                 print 'Mailbox',mbox,'has',len(msgs),'messages:'
 221                 for msg in msgs:
 222                         f = msg.getheader('from') or ""
 223                         s = msg.getheader('subject') or ""
 224                         d = msg.getheader('date') or ""
 225                         print '%20.20s   %18.18s   %-30.30s'%(f, d[5:], s)
 226
 227
 228 if __name__ == '__main__':
 229         _test()