diff options
Diffstat (limited to 'Mailman/pythonlib')
| -rw-r--r-- | Mailman/pythonlib/rfc822.py | 951 | ||||
| -rwxr-xr-x | Mailman/pythonlib/smtplib.py | 550 | ||||
| -rw-r--r-- | Mailman/pythonlib/tempfile.py | 146 |
3 files changed, 0 insertions, 1647 deletions
diff --git a/Mailman/pythonlib/rfc822.py b/Mailman/pythonlib/rfc822.py deleted file mode 100644 index d7403b23a..000000000 --- a/Mailman/pythonlib/rfc822.py +++ /dev/null @@ -1,951 +0,0 @@ -"""RFC-822 message manipulation class. - -XXX This is only a very rough sketch of a full RFC-822 parser; -in particular the tokenizing of addresses does not adhere to all the -quoting rules. - -Directions for use: - -To create a Message object: first open a file, e.g.: - fp = open(file, 'r') -You can use any other legal way of getting an open file object, e.g. use -sys.stdin or call os.popen(). -Then pass the open file object to the Message() constructor: - m = Message(fp) - -This class can work with any input object that supports a readline -method. If the input object has seek and tell capability, the -rewindbody method will work; also illegal lines will be pushed back -onto the input stream. If the input object lacks seek but has an -`unread' method that can push back a line of input, Message will use -that to push back illegal lines. Thus this class can be used to parse -messages coming from a buffered stream. - -The optional `seekable' argument is provided as a workaround for -certain stdio libraries in which tell() discards buffered data before -discovering that the lseek() system call doesn't work. For maximum -portability, you should set the seekable argument to zero to prevent -that initial \code{tell} when passing in an unseekable object such as -a a file object created from a socket object. If it is 1 on entry -- -which it is by default -- the tell() method of the open file object is -called once; if this raises an exception, seekable is reset to 0. For -other nonzero values of seekable, this test is not made. - -To get the text of a particular header there are several methods: - str = m.getheader(name) - str = m.getrawheader(name) -where name is the name of the header, e.g. 'Subject'. -The difference is that getheader() strips the leading and trailing -whitespace, while getrawheader() doesn't. Both functions retain -embedded whitespace (including newlines) exactly as they are -specified in the header, and leave the case of the text unchanged. - -For addresses and address lists there are functions - realname, mailaddress = m.getaddr(name) and - list = m.getaddrlist(name) -where the latter returns a list of (realname, mailaddr) tuples. - -There is also a method - time = m.getdate(name) -which parses a Date-like field and returns a time-compatible tuple, -i.e. a tuple such as returned by time.localtime() or accepted by -time.mktime(). - -See the class definition for lower level access methods. - -There are also some utility functions here. -""" -# Cleanup and extensions by Eric S. Raymond <esr@thyrsus.com> - -import string -import time - - -_blanklines = ('\r\n', '\n') # Optimization for islast() - - -class Message: - """Represents a single RFC-822-compliant message.""" - - def __init__(self, fp, seekable = 1): - """Initialize the class instance and read the headers.""" - if seekable == 1: - # Exercise tell() to make sure it works - # (and then assume seek() works, too) - try: - fp.tell() - except: - seekable = 0 - else: - seekable = 1 - self.fp = fp - self.seekable = seekable - self.startofheaders = None - self.startofbody = None - # - if self.seekable: - try: - self.startofheaders = self.fp.tell() - except IOError: - self.seekable = 0 - # - self.readheaders() - # - if self.seekable: - try: - self.startofbody = self.fp.tell() - except IOError: - self.seekable = 0 - - def rewindbody(self): - """Rewind the file to the start of the body (if seekable).""" - if not self.seekable: - raise IOError, "unseekable file" - self.fp.seek(self.startofbody) - - def readheaders(self): - """Read header lines. - - Read header lines up to the entirely blank line that - terminates them. The (normally blank) line that ends the - headers is skipped, but not included in the returned list. - If a non-header line ends the headers, (which is an error), - an attempt is made to backspace over it; it is never - included in the returned list. - - The variable self.status is set to the empty string if all - went well, otherwise it is an error message. - The variable self.headers is a completely uninterpreted list - of lines contained in the header (so printing them will - reproduce the header exactly as it appears in the file). - """ - self.dict = {} - self.unixfrom = '' - self.headers = list = [] - self.status = '' - headerseen = "" - firstline = 1 - startofline = unread = tell = None - if hasattr(self.fp, 'unread'): - unread = self.fp.unread - elif self.seekable: - tell = self.fp.tell - while 1: - if tell: - startofline = tell() - line = self.fp.readline() - if not line: - self.status = 'EOF in headers' - break - # Skip unix From name time lines - if firstline and line[:5] == 'From ': - self.unixfrom = self.unixfrom + line - continue - firstline = 0 - if headerseen and line[0] in ' \t': - # It's a continuation line. - list.append(line) - x = (self.dict[headerseen] + "\n " + string.strip(line)) - self.dict[headerseen] = string.strip(x) - continue - elif self.iscomment(line): - # It's a comment. Ignore it. - continue - elif self.islast(line): - # Note! No pushback here! The delimiter line gets eaten. - break - headerseen = self.isheader(line) - if headerseen: - # It's a legal header line, save it. - list.append(line) - self.dict[headerseen] = string.strip(line[len(headerseen)+2:]) - continue - else: - # It's not a header line; throw it back and stop here. - if not self.dict: - self.status = 'No headers' - else: - self.status = 'Non-header line where header expected' - # Try to undo the read. - if unread: - unread(line) - elif tell: - self.fp.seek(startofline) - else: - self.status = self.status + '; bad seek' - break - - def isheader(self, line): - """Determine whether a given line is a legal header. - - This method should return the header name, suitably canonicalized. - You may override this method in order to use Message parsing - on tagged data in RFC822-like formats with special header formats. - """ - i = string.find(line, ':') - if i > 0: - return string.lower(line[:i]) - else: - return None - - def islast(self, line): - """Determine whether a line is a legal end of RFC-822 headers. - - You may override this method if your application wants - to bend the rules, e.g. to strip trailing whitespace, - or to recognise MH template separators ('--------'). - For convenience (e.g. for code reading from sockets) a - line consisting of \r\n also matches. - """ - return line in _blanklines - - def iscomment(self, line): - """Determine whether a line should be skipped entirely. - - You may override this method in order to use Message parsing - on tagged data in RFC822-like formats that support embedded - comments or free-text data. - """ - return None - - def getallmatchingheaders(self, name): - """Find all header lines matching a given header name. - - Look through the list of headers and find all lines - matching a given header name (and their continuation - lines). A list of the lines is returned, without - interpretation. If the header does not occur, an - empty list is returned. If the header occurs multiple - times, all occurrences are returned. Case is not - important in the header name. - """ - name = string.lower(name) + ':' - n = len(name) - list = [] - hit = 0 - for line in self.headers: - if string.lower(line[:n]) == name: - hit = 1 - elif line[:1] not in string.whitespace: - hit = 0 - if hit: - list.append(line) - return list - - def getfirstmatchingheader(self, name): - """Get the first header line matching name. - - This is similar to getallmatchingheaders, but it returns - only the first matching header (and its continuation - lines). - """ - name = string.lower(name) + ':' - n = len(name) - list = [] - hit = 0 - for line in self.headers: - if hit: - if line[:1] not in string.whitespace: - break - elif string.lower(line[:n]) == name: - hit = 1 - if hit: - list.append(line) - return list - - def getrawheader(self, name): - """A higher-level interface to getfirstmatchingheader(). - - Return a string containing the literal text of the - header but with the keyword stripped. All leading, - trailing and embedded whitespace is kept in the - string, however. - Return None if the header does not occur. - """ - - list = self.getfirstmatchingheader(name) - if not list: - return None - list[0] = list[0][len(name) + 1:] - return string.joinfields(list, '') - - def getheader(self, name, default=None): - """Get the header value for a name. - - This is the normal interface: it returns a stripped - version of the header value for a given header name, - or None if it doesn't exist. This uses the dictionary - version which finds the *last* such header. - """ - try: - return self.dict[string.lower(name)] - except KeyError: - return default - get = getheader - - def getheaders(self, name): - """Get all values for a header. - - This returns a list of values for headers given more than once; - each value in the result list is stripped in the same way as the - result of getheader(). If the header is not given, return an - empty list. - """ - result = [] - current = '' - have_header = 0 - for s in self.getallmatchingheaders(name): - if s[0] in string.whitespace: - if current: - current = "%s\n %s" % (current, string.strip(s)) - else: - current = string.strip(s) - else: - if have_header: - result.append(current) - current = string.strip(s[string.find(s, ":") + 1:]) - have_header = 1 - if have_header: - result.append(current) - return result - - def getaddr(self, name): - """Get a single address from a header, as a tuple. - - An example return value: - ('Guido van Rossum', 'guido@cwi.nl') - """ - # New, by Ben Escoto - alist = self.getaddrlist(name) - if alist: - return alist[0] - else: - return (None, None) - - def getaddrlist(self, name): - """Get a list of addresses from a header. - - Retrieves a list of addresses from a header, where each address is a - tuple as returned by getaddr(). Scans all named headers, so it works - properly with multiple To: or Cc: headers for example. - - """ - raw = [] - for h in self.getallmatchingheaders(name): - if h[0] in ' \t': - raw.append(h) - else: - if raw: - raw.append(', ') - i = string.find(h, ':') - if i > 0: - addr = h[i+1:] - raw.append(addr) - alladdrs = string.join(raw, '') - a = AddrlistClass(alladdrs) - return a.getaddrlist() - - def getdate(self, name): - """Retrieve a date field from a header. - - Retrieves a date field from the named header, returning - a tuple compatible with time.mktime(). - """ - try: - data = self[name] - except KeyError: - return None - return parsedate(data) - - def getdate_tz(self, name): - """Retrieve a date field from a header as a 10-tuple. - - The first 9 elements make up a tuple compatible with - time.mktime(), and the 10th is the offset of the poster's - time zone from GMT/UTC. - """ - try: - data = self[name] - except KeyError: - return None - return parsedate_tz(data) - - - # Access as a dictionary (only finds *last* header of each type): - - def __len__(self): - """Get the number of headers in a message.""" - return len(self.dict) - - def __getitem__(self, name): - """Get a specific header, as from a dictionary.""" - return self.dict[string.lower(name)] - - def __setitem__(self, name, value): - """Set the value of a header. - - Note: This is not a perfect inversion of __getitem__, because - any changed headers get stuck at the end of the raw-headers list - rather than where the altered header was. - """ - del self[name] # Won't fail if it doesn't exist - self.dict[string.lower(name)] = value - text = name + ": " + value - lines = string.split(text, "\n") - for line in lines: - self.headers.append(line + "\n") - - def __delitem__(self, name): - """Delete all occurrences of a specific header, if it is present.""" - name = string.lower(name) - if not self.dict.has_key(name): - return - del self.dict[name] - name = name + ':' - n = len(name) - list = [] - hit = 0 - for i in range(len(self.headers)): - line = self.headers[i] - if string.lower(line[:n]) == name: - hit = 1 - elif line[:1] not in string.whitespace: - hit = 0 - if hit: - list.append(i) - list.reverse() - for i in list: - del self.headers[i] - - def has_key(self, name): - """Determine whether a message contains the named header.""" - return self.dict.has_key(string.lower(name)) - - def keys(self): - """Get all of a message's header field names.""" - return self.dict.keys() - - def values(self): - """Get all of a message's header field values.""" - return self.dict.values() - - def items(self): - """Get all of a message's headers. - - Returns a list of name, value tuples. - """ - return self.dict.items() - - def __str__(self): - str = '' - for hdr in self.headers: - str = str + hdr - return str - - -# Utility functions -# ----------------- - -# XXX Should fix unquote() and quote() to be really conformant. -# XXX The inverses of the parse functions may also be useful. - - -def unquote(str): - """Remove quotes from a string.""" - if len(str) > 1: - if str[0] == '"' and str[-1:] == '"': - return str[1:-1] - if str[0] == '<' and str[-1:] == '>': - return str[1:-1] - return str - - -def quote(str): - """Add quotes around a string.""" - return '"%s"' % string.join( - string.split( - string.join( - string.split(str, '\\'), - '\\\\'), - '"'), - '\\"') - - -def parseaddr(address): - """Parse an address into a (realname, mailaddr) tuple.""" - a = AddrlistClass(address) - list = a.getaddrlist() - if not list: - return (None, None) - else: - return list[0] - - -class AddrlistClass: - """Address parser class by Ben Escoto. - - To understand what this class does, it helps to have a copy of - RFC-822 in front of you. - - Note: this class interface is deprecated and may be removed in the future. - Use rfc822.AddressList instead. - """ - - def __init__(self, field): - """Initialize a new instance. - - `field' is an unparsed address header field, containing - one or more addresses. - """ - self.specials = '()<>@,:;.\"[]' - self.pos = 0 - self.LWS = ' \t' - self.CR = '\r\n' - self.atomends = self.specials + self.LWS + self.CR - self.field = field - self.commentlist = [] - - def gotonext(self): - """Parse up to the start of the next address.""" - while self.pos < len(self.field): - if self.field[self.pos] in self.LWS + '\n\r': - self.pos = self.pos + 1 - elif self.field[self.pos] == '(': - self.commentlist.append(self.getcomment()) - else: break - - def getaddrlist(self): - """Parse all addresses. - - Returns a list containing all of the addresses. - """ - ad = self.getaddress() - if ad: - return ad + self.getaddrlist() - else: return [] - - def getaddress(self): - """Parse the next address.""" - self.commentlist = [] - self.gotonext() - - oldpos = self.pos - oldcl = self.commentlist - plist = self.getphraselist() - - self.gotonext() - returnlist = [] - - if self.pos >= len(self.field): - # Bad email address technically, no domain. - if plist: - returnlist = [(string.join(self.commentlist), plist[0])] - - elif self.field[self.pos] in '.@': - # email address is just an addrspec - # this isn't very efficient since we start over - self.pos = oldpos - self.commentlist = oldcl - addrspec = self.getaddrspec() - returnlist = [(string.join(self.commentlist), addrspec)] - - elif self.field[self.pos] == ':': - # address is a group - returnlist = [] - - fieldlen = len(self.field) - self.pos = self.pos + 1 - while self.pos < fieldlen: - self.gotonext() - if self.pos < fieldlen and self.field[self.pos] == ';': - self.pos = self.pos + 1 - break - returnlist = returnlist + self.getaddress() - - elif self.field[self.pos] == '<': - # Address is a phrase then a route addr - routeaddr = self.getrouteaddr() - - if self.commentlist: - returnlist = [(string.join(plist) + ' (' + \ - string.join(self.commentlist) + ')', routeaddr)] - else: returnlist = [(string.join(plist), routeaddr)] - - else: - if plist: - returnlist = [(string.join(self.commentlist), plist[0])] - elif self.field[self.pos] in self.specials: - self.pos = self.pos + 1 - - self.gotonext() - if self.pos < len(self.field) and self.field[self.pos] == ',': - self.pos = self.pos + 1 - return returnlist - - def getrouteaddr(self): - """Parse a route address (Return-path value). - - This method just skips all the route stuff and returns the addrspec. - """ - if self.field[self.pos] != '<': - return - - expectroute = 0 - self.pos = self.pos + 1 - self.gotonext() - adlist = None - while self.pos < len(self.field): - if expectroute: - self.getdomain() - expectroute = 0 - elif self.field[self.pos] == '>': - self.pos = self.pos + 1 - break - elif self.field[self.pos] == '@': - self.pos = self.pos + 1 - expectroute = 1 - elif self.field[self.pos] == ':': - self.pos = self.pos + 1 - expectaddrspec = 1 - else: - adlist = self.getaddrspec() - self.pos = self.pos + 1 - break - self.gotonext() - - return adlist - - def getaddrspec(self): - """Parse an RFC-822 addr-spec.""" - aslist = [] - - self.gotonext() - while self.pos < len(self.field): - if self.field[self.pos] == '.': - aslist.append('.') - self.pos = self.pos + 1 - elif self.field[self.pos] == '"': - aslist.append('"%s"' % self.getquote()) - elif self.field[self.pos] in self.atomends: - break - else: aslist.append(self.getatom()) - self.gotonext() - - if self.pos >= len(self.field) or self.field[self.pos] != '@': - return string.join(aslist, '') - - aslist.append('@') - self.pos = self.pos + 1 - self.gotonext() - return string.join(aslist, '') + self.getdomain() - - def getdomain(self): - """Get the complete domain name from an address.""" - sdlist = [] - while self.pos < len(self.field): - if self.field[self.pos] in self.LWS: - self.pos = self.pos + 1 - elif self.field[self.pos] == '(': - self.commentlist.append(self.getcomment()) - elif self.field[self.pos] == '[': - sdlist.append(self.getdomainliteral()) - elif self.field[self.pos] == '.': - self.pos = self.pos + 1 - sdlist.append('.') - elif self.field[self.pos] in self.atomends: - break - else: sdlist.append(self.getatom()) - return string.join(sdlist, '') - - def getdelimited(self, beginchar, endchars, allowcomments = 1): - """Parse a header fragment delimited by special characters. - - `beginchar' is the start character for the fragment. - If self is not looking at an instance of `beginchar' then - getdelimited returns the empty string. - - `endchars' is a sequence of allowable end-delimiting characters. - Parsing stops when one of these is encountered. - - If `allowcomments' is non-zero, embedded RFC-822 comments - are allowed within the parsed fragment. - """ - if self.field[self.pos] != beginchar: - return '' - - slist = [''] - quote = 0 - self.pos = self.pos + 1 - while self.pos < len(self.field): - if quote == 1: - slist.append(self.field[self.pos]) - quote = 0 - elif self.field[self.pos] in endchars: - self.pos = self.pos + 1 - break - elif allowcomments and self.field[self.pos] == '(': - slist.append(self.getcomment()) - elif self.field[self.pos] == '\\': - quote = 1 - else: - slist.append(self.field[self.pos]) - self.pos = self.pos + 1 - - return string.join(slist, '') - - def getquote(self): - """Get a quote-delimited fragment from self's field.""" - return self.getdelimited('"', '"\r', 0) - - def getcomment(self): - """Get a parenthesis-delimited fragment from self's field.""" - return self.getdelimited('(', ')\r', 1) - - def getdomainliteral(self): - """Parse an RFC-822 domain-literal.""" - return self.getdelimited('[', ']\r', 0) - - def getatom(self): - """Parse an RFC-822 atom.""" - atomlist = [''] - - while self.pos < len(self.field): - if self.field[self.pos] in self.atomends: - break - else: atomlist.append(self.field[self.pos]) - self.pos = self.pos + 1 - - return string.join(atomlist, '') - - def getphraselist(self): - """Parse a sequence of RFC-822 phrases. - - A phrase is a sequence of words, which are in turn either - RFC-822 atoms or quoted-strings. Phrases are canonicalized - by squeezing all runs of continuous whitespace into one space. - """ - plist = [] - - while self.pos < len(self.field): - if self.field[self.pos] in self.LWS: - self.pos = self.pos + 1 - elif self.field[self.pos] == '"': - plist.append(self.getquote()) - elif self.field[self.pos] == '(': - self.commentlist.append(self.getcomment()) - elif self.field[self.pos] in self.atomends: - break - else: plist.append(self.getatom()) - - return plist - -class AddressList(AddrlistClass): - """An AddressList encapsulates a list of parsed RFC822 addresses.""" - def __init__(self, field): - AddrlistClass.__init__(self, field) - if field: - self.addresslist = self.getaddrlist() - else: - self.addresslist = [] - - def __len__(self): - return len(self.addresslist) - - def __str__(self): - return string.joinfields(map(dump_address_pair, self.addresslist),", ") - - def __add__(self, other): - # Set union - newaddr = AddressList(None) - newaddr.addresslist = self.addresslist[:] - for x in other.addresslist: - if not x in self.addresslist: - newaddr.addresslist.append(x) - return newaddr - - def __sub__(self, other): - # Set difference - newaddr = AddressList(None) - for x in self.addresslist: - if not x in other.addresslist: - newaddr.addresslist.append(x) - return newaddr - - def __getitem__(self, index): - # Make indexing, slices, and 'in' work - return self.addrlist[index] - -def dump_address_pair(pair): - """Dump a (name, address) pair in a canonicalized form.""" - if pair[0]: - return '"' + pair[0] + '" <' + pair[1] + '>' - else: - return pair[1] - -# Parse a date field - -_monthnames = ['jan', 'feb', 'mar', 'apr', 'may', 'jun', 'jul', - 'aug', 'sep', 'oct', 'nov', 'dec', - 'january', 'february', 'march', 'april', 'may', 'june', 'july', - 'august', 'september', 'october', 'november', 'december'] -_daynames = ['mon', 'tue', 'wed', 'thu', 'fri', 'sat', 'sun'] - -# The timezone table does not include the military time zones defined -# in RFC822, other than Z. According to RFC1123, the description in -# RFC822 gets the signs wrong, so we can't rely on any such time -# zones. RFC1123 recommends that numeric timezone indicators be used -# instead of timezone names. - -_timezones = {'UT':0, 'UTC':0, 'GMT':0, 'Z':0, - 'AST': -400, 'ADT': -300, # Atlantic (used in Canada) - 'EST': -500, 'EDT': -400, # Eastern - 'CST': -600, 'CDT': -500, # Central - 'MST': -700, 'MDT': -600, # Mountain - 'PST': -800, 'PDT': -700 # Pacific - } - - -def parsedate_tz(data): - """Convert a date string to a time tuple. - - Accounts for military timezones. - """ - data = string.split(data) - if data[0][-1] in (',', '.') or string.lower(data[0]) in _daynames: - # There's a dayname here. Skip it - del data[0] - if len(data) == 3: # RFC 850 date, deprecated - stuff = string.split(data[0], '-') - if len(stuff) == 3: - data = stuff + data[1:] - if len(data) == 4: - s = data[3] - i = string.find(s, '+') - if i > 0: - data[3:] = [s[:i], s[i+1:]] - else: - data.append('') # Dummy tz - if len(data) < 5: - return None - data = data[:5] - [dd, mm, yy, tm, tz] = data - mm = string.lower(mm) - if not mm in _monthnames: - dd, mm = mm, string.lower(dd) - if not mm in _monthnames: - return None - mm = _monthnames.index(mm)+1 - if mm > 12: mm = mm - 12 - if dd[-1] == ',': - dd = dd[:-1] - i = string.find(yy, ':') - if i > 0: - yy, tm = tm, yy - if yy[-1] == ',': - yy = yy[:-1] - if yy[0] not in string.digits: - yy, tz = tz, yy - if tm[-1] == ',': - tm = tm[:-1] - tm = string.splitfields(tm, ':') - if len(tm) == 2: - [thh, tmm] = tm - tss = '0' - elif len(tm) == 3: - [thh, tmm, tss] = tm - else: - return None - try: - yy = string.atoi(yy) - dd = string.atoi(dd) - thh = string.atoi(thh) - tmm = string.atoi(tmm) - tss = string.atoi(tss) - except string.atoi_error: - return None - tzoffset=None - tz=string.upper(tz) - if _timezones.has_key(tz): - tzoffset=_timezones[tz] - else: - try: - tzoffset=string.atoi(tz) - except string.atoi_error: - pass - # Convert a timezone offset into seconds ; -0500 -> -18000 - if tzoffset: - if tzoffset < 0: - tzsign = -1 - tzoffset = -tzoffset - else: - tzsign = 1 - tzoffset = tzsign * ( (tzoffset/100)*3600 + (tzoffset % 100)*60) - tuple = (yy, mm, dd, thh, tmm, tss, 0, 0, 0, tzoffset) - return tuple - - -def parsedate(data): - """Convert a time string to a time tuple.""" - t=parsedate_tz(data) - if type(t)==type( () ): - return t[:9] - else: return t - - -def mktime_tz(data): - """Turn a 10-tuple as returned by parsedate_tz() into a UTC timestamp.""" - if data[9] is None: - # No zone info, so localtime is better assumption than GMT - return time.mktime(data[:8] + (-1,)) - else: - t = time.mktime(data[:8] + (0,)) - return t - data[9] - time.timezone - -def formatdate(timeval=None): - """Returns time format preferred for Internet standards. - - Sun, 06 Nov 1994 08:49:37 GMT ; RFC 822, updated by RFC 1123 - """ - if timeval is None: - timeval = time.time() - return "%s" % time.strftime('%a, %d %b %Y %H:%M:%S GMT', - time.gmtime(timeval)) - - -# When used as script, run a small test program. -# The first command line argument must be a filename containing one -# message in RFC-822 format. - -if __name__ == '__main__': - import sys, os - file = os.path.join(os.environ['HOME'], 'Mail/inbox/1') - if sys.argv[1:]: file = sys.argv[1] - f = open(file, 'r') - m = Message(f) - print 'From:', m.getaddr('from') - print 'To:', m.getaddrlist('to') - print 'Subject:', m.getheader('subject') - print 'Date:', m.getheader('date') - date = m.getdate_tz('date') - if date: - print 'ParsedDate:', time.asctime(date[:-1]), - hhmmss = date[-1] - hhmm, ss = divmod(hhmmss, 60) - hh, mm = divmod(hhmm, 60) - print "%+03d%02d" % (hh, mm), - if ss: print ".%02d" % ss, - print - else: - print 'ParsedDate:', None - m.rewindbody() - n = 0 - while f.readline(): - n = n + 1 - print 'Lines:', n - print '-'*70 - print 'len =', len(m) - if m.has_key('Date'): print 'Date =', m['Date'] - if m.has_key('X-Nonsense'): pass - print 'keys =', m.keys() - print 'values =', m.values() - print 'items =', m.items() diff --git a/Mailman/pythonlib/smtplib.py b/Mailman/pythonlib/smtplib.py deleted file mode 100755 index 0ac6018e9..000000000 --- a/Mailman/pythonlib/smtplib.py +++ /dev/null @@ -1,550 +0,0 @@ -#! /usr/bin/env python - -'''SMTP/ESMTP client class. - -This should follow RFC 821 (SMTP) and RFC 1869 (ESMTP). - -Notes: - -Please remember, when doing ESMTP, that the names of the SMTP service -extensions are NOT the same thing as the option keywords for the RCPT -and MAIL commands! - -Example: - - >>> import smtplib - >>> s=smtplib.SMTP("localhost") - >>> print s.help() - This is Sendmail version 8.8.4 - Topics: - HELO EHLO MAIL RCPT DATA - RSET NOOP QUIT HELP VRFY - EXPN VERB ETRN DSN - For more info use "HELP <topic>". - To report bugs in the implementation send email to - sendmail-bugs@sendmail.org. - For local information send email to Postmaster at your site. - End of HELP info - >>> s.putcmd("vrfy","someone@here") - >>> s.getreply() - (250, "Somebody OverHere <somebody@here.my.org>") - >>> s.quit() -''' - -# Author: The Dragon De Monsyne <dragondm@integral.org> -# ESMTP support, test code and doc fixes added by -# Eric S. Raymond <esr@thyrsus.com> -# Better RFC 821 compliance (MAIL and RCPT, and CRLF in data) -# by Carey Evans <c.evans@clear.net.nz>, for picky mail servers. -# -# This was modified from the Python 1.5 library HTTP lib. - -import socket -import string -import re -import rfc822 -import types - -SMTP_PORT = 25 -CRLF="\r\n" - -# Exception classes used by this module. -class SMTPException(Exception): - """Base class for all exceptions raised by this module.""" - -class SMTPServerDisconnected(SMTPException): - """Not connected to any SMTP server. - - This exception is raised when the server unexpectedly disconnects, - or when an attempt is made to use the SMTP instance before - connecting it to a server. - """ - -class SMTPResponseException(SMTPException): - """Base class for all exceptions that include an SMTP error code. - - These exceptions are generated in some instances when the SMTP - server returns an error code. The error code is stored in the - `smtp_code' attribute of the error, and the `smtp_error' attribute - is set to the error message. - """ - - def __init__(self, code, msg): - self.smtp_code = code - self.smtp_error = msg - self.args = (code, msg) - -class SMTPSenderRefused(SMTPResponseException): - """Sender address refused. - In addition to the attributes set by on all SMTPResponseException - exceptions, this sets `sender' to the string that the SMTP refused. - """ - - def __init__(self, code, msg, sender): - self.smtp_code = code - self.smtp_error = msg - self.sender = sender - self.args = (code, msg, sender) - -class SMTPRecipientsRefused(SMTPException): - """All recipient addresses refused. - The errors for each recipient are accessible through the attribute - 'recipients', which is a dictionary of exactly the same sort as - SMTP.sendmail() returns. - """ - - def __init__(self, recipients): - self.recipients = recipients - self.args = ( recipients,) - - -class SMTPDataError(SMTPResponseException): - """The SMTP server didn't accept the data.""" - -class SMTPConnectError(SMTPResponseException): - """Error during connection establishment.""" - -class SMTPHeloError(SMTPResponseException): - """The server refused our HELO reply.""" - - -def quoteaddr(addr): - """Quote a subset of the email addresses defined by RFC 821. - - Should be able to handle anything rfc822.parseaddr can handle. - """ - m=None - try: - m=rfc822.parseaddr(addr)[1] - except AttributeError: - pass - if not m: - #something weird here.. punt -ddm - return addr - else: - return "<%s>" % m - -def quotedata(data): - """Quote data for email. - - Double leading '.', and change Unix newline '\\n', or Mac '\\r' into - Internet CRLF end-of-line. - """ - return re.sub(r'(?m)^\.', '..', - re.sub(r'(?:\r\n|\n|\r(?!\n))', CRLF, data)) - -def _get_fqdn_hostname(name): - name = string.strip(name) - if len(name) == 0: - name = socket.gethostname() - try: - hostname, aliases, ipaddrs = socket.gethostbyaddr(name) - except socket.error: - pass - else: - aliases.insert(0, hostname) - for name in aliases: - if '.' in name: - break - else: - name = hostname - return name - - -class SMTP: - """This class manages a connection to an SMTP or ESMTP server. - SMTP Objects: - SMTP objects have the following attributes: - helo_resp - This is the message given by the server in response to the - most recent HELO command. - - ehlo_resp - This is the message given by the server in response to the - most recent EHLO command. This is usually multiline. - - does_esmtp - This is a True value _after you do an EHLO command_, if the - server supports ESMTP. - - esmtp_features - This is a dictionary, which, if the server supports ESMTP, - will _after you do an EHLO command_, contain the names of the - SMTP service extensions this server supports, and their - parameters (if any). - - Note, all extension names are mapped to lower case in the - dictionary. - - See each method's docstrings for details. In general, there is a - method of the same name to perform each SMTP command. There is also a - method called 'sendmail' that will do an entire mail transaction. - """ - debuglevel = 0 - file = None - helo_resp = None - ehlo_resp = None - does_esmtp = 0 - - def __init__(self, host = '', port = 0): - """Initialize a new instance. - - If specified, `host' is the name of the remote host to which to - connect. If specified, `port' specifies the port to which to connect. - By default, smtplib.SMTP_PORT is used. An SMTPConnectError is raised - if the specified `host' doesn't respond correctly. - - """ - self.esmtp_features = {} - if host: - (code, msg) = self.connect(host, port) - if code != 220: - raise SMTPConnectError(code, msg) - - def set_debuglevel(self, debuglevel): - """Set the debug output level. - - A non-false value results in debug messages for connection and for all - messages sent to and received from the server. - - """ - self.debuglevel = debuglevel - - def connect(self, host='localhost', port = 0): - """Connect to a host on a given port. - - If the hostname ends with a colon (`:') followed by a number, and - there is no port specified, that suffix will be stripped off and the - number interpreted as the port number to use. - - Note: This method is automatically invoked by __init__, if a host is - specified during instantiation. - - """ - if not port: - i = string.find(host, ':') - if i >= 0: - host, port = host[:i], host[i+1:] - try: port = string.atoi(port) - except string.atoi_error: - raise socket.error, "nonnumeric port" - if not port: port = SMTP_PORT - self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) - if self.debuglevel > 0: print 'connect:', (host, port) - try: - self.sock.connect((host, port)) - except socket.error: - self.close() - raise - (code,msg)=self.getreply() - if self.debuglevel >0 : print "connect:", msg - return (code,msg) - - def send(self, str): - """Send `str' to the server.""" - if self.debuglevel > 0: print 'send:', `str` - if self.sock: - try: - sendptr = 0 - while sendptr < len(str): - sendptr = sendptr + self.sock.send(str[sendptr:]) - except socket.error: - raise SMTPServerDisconnected('Server not connected') - else: - raise SMTPServerDisconnected('please run connect() first') - - def putcmd(self, cmd, args=""): - """Send a command to the server.""" - if args == "": - str = '%s%s' % (cmd, CRLF) - else: - str = '%s %s%s' % (cmd, args, CRLF) - self.send(str) - - def getreply(self): - """Get a reply from the server. - - Returns a tuple consisting of: - - - server response code (e.g. '250', or such, if all goes well) - Note: returns -1 if it can't read response code. - - - server response string corresponding to response code (multiline - responses are converted to a single, multiline string). - - Raises SMTPServerDisconnected if end-of-file is reached. - """ - resp=[] - if self.file is None: - self.file = self.sock.makefile('rb') - while 1: - line = self.file.readline() - if line == '': - self.close() - raise SMTPServerDisconnected("Connection unexpectedly closed") - if self.debuglevel > 0: print 'reply:', `line` - resp.append(string.strip(line[4:])) - code=line[:3] - # Check that the error code is syntactically correct. - # Don't attempt to read a continuation line if it is broken. - try: - errcode = string.atoi(code) - except ValueError: - errcode = -1 - break - # Check if multiline response. - if line[3:4]!="-": - break - - errmsg = string.join(resp,"\n") - if self.debuglevel > 0: - print 'reply: retcode (%s); Msg: %s' % (errcode,errmsg) - return errcode, errmsg - - def docmd(self, cmd, args=""): - """Send a command, and return its response code.""" - self.putcmd(cmd,args) - return self.getreply() - - # std smtp commands - def helo(self, name=''): - """SMTP 'helo' command. - Hostname to send for this command defaults to the FQDN of the local - host. - """ - self.putcmd("helo", _get_fqdn_hostname(name)) - (code,msg)=self.getreply() - self.helo_resp=msg - return (code,msg) - - def ehlo(self, name=''): - """ SMTP 'ehlo' command. - Hostname to send for this command defaults to the FQDN of the local - host. - """ - self.putcmd("ehlo", _get_fqdn_hostname(name)) - (code,msg)=self.getreply() - # According to RFC1869 some (badly written) - # MTA's will disconnect on an ehlo. Toss an exception if - # that happens -ddm - if code == -1 and len(msg) == 0: - raise SMTPServerDisconnected("Server not connected") - self.ehlo_resp=msg - if code<>250: - return (code,msg) - self.does_esmtp=1 - #parse the ehlo response -ddm - resp=string.split(self.ehlo_resp,'\n') - del resp[0] - for each in resp: - m=re.match(r'(?P<feature>[A-Za-z0-9][A-Za-z0-9\-]*)',each) - if m: - feature=string.lower(m.group("feature")) - params=string.strip(m.string[m.end("feature"):]) - self.esmtp_features[feature]=params - return (code,msg) - - def has_extn(self, opt): - """Does the server support a given SMTP service extension?""" - return self.esmtp_features.has_key(string.lower(opt)) - - def help(self, args=''): - """SMTP 'help' command. - Returns help text from server.""" - self.putcmd("help", args) - return self.getreply() - - def rset(self): - """SMTP 'rset' command -- resets session.""" - return self.docmd("rset") - - def noop(self): - """SMTP 'noop' command -- doesn't do anything :>""" - return self.docmd("noop") - - def mail(self,sender,options=[]): - """SMTP 'mail' command -- begins mail xfer session.""" - optionlist = '' - if options and self.does_esmtp: - optionlist = ' ' + string.join(options, ' ') - self.putcmd("mail", "FROM:%s%s" % (quoteaddr(sender) ,optionlist)) - return self.getreply() - - def rcpt(self,recip,options=[]): - """SMTP 'rcpt' command -- indicates 1 recipient for this mail.""" - optionlist = '' - if options and self.does_esmtp: - optionlist = ' ' + string.join(options, ' ') - self.putcmd("rcpt","TO:%s%s" % (quoteaddr(recip),optionlist)) - return self.getreply() - - def data(self,msg): - """SMTP 'DATA' command -- sends message data to server. - - Automatically quotes lines beginning with a period per rfc821. - Raises SMTPDataError if there is an unexpected reply to the - DATA command; the return value from this method is the final - response code received when the all data is sent. - """ - self.putcmd("data") - (code,repl)=self.getreply() - if self.debuglevel >0 : print "data:", (code,repl) - if code <> 354: - raise SMTPDataError(code,repl) - else: - q = quotedata(msg) - if q[-2:] != CRLF: - q = q + CRLF - q = q + "." + CRLF - self.send(q) - (code,msg)=self.getreply() - if self.debuglevel >0 : print "data:", (code,msg) - return (code,msg) - - def verify(self, address): - """SMTP 'verify' command -- checks for address validity.""" - self.putcmd("vrfy", quoteaddr(address)) - return self.getreply() - # a.k.a. - vrfy=verify - - def expn(self, address): - """SMTP 'verify' command -- checks for address validity.""" - self.putcmd("expn", quoteaddr(address)) - return self.getreply() - - # some useful methods - def sendmail(self, from_addr, to_addrs, msg, mail_options=[], - rcpt_options=[]): - """This command performs an entire mail transaction. - - The arguments are: - - from_addr : The address sending this mail. - - to_addrs : A list of addresses to send this mail to. A bare - string will be treated as a list with 1 address. - - msg : The message to send. - - mail_options : List of ESMTP options (such as 8bitmime) for the - mail command. - - rcpt_options : List of ESMTP options (such as DSN commands) for - all the rcpt commands. - - If there has been no previous EHLO or HELO command this session, this - method tries ESMTP EHLO first. If the server does ESMTP, message size - and each of the specified options will be passed to it. If EHLO - fails, HELO will be tried and ESMTP options suppressed. - - This method will return normally if the mail is accepted for at least - one recipient. It returns a dictionary, with one entry for each - recipient that was refused. Each entry contains a tuple of the SMTP - error code and the accompanying error message sent by the server. - - This method may raise the following exceptions: - - SMTPHeloError The server didn't reply properly to - the helo greeting. - SMTPRecipientsRefused The server rejected ALL recipients - (no mail was sent). - SMTPSenderRefused The server didn't accept the from_addr. - SMTPDataError The server replied with an unexpected - error code (other than a refusal of - a recipient). - - Note: the connection will be open even after an exception is raised. - - Example: - - >>> import smtplib - >>> s=smtplib.SMTP("localhost") - >>> tolist=["one@one.org","two@two.org","three@three.org","four@four.org"] - >>> msg = ''' - ... From: Me@my.org - ... Subject: testin'... - ... - ... This is a test ''' - >>> s.sendmail("me@my.org",tolist,msg) - { "three@three.org" : ( 550 ,"User unknown" ) } - >>> s.quit() - - In the above example, the message was accepted for delivery to three - of the four addresses, and one was rejected, with the error code - 550. If all addresses are accepted, then the method will return an - empty dictionary. - - """ - if self.helo_resp is None and self.ehlo_resp is None: - if not (200 <= self.ehlo()[0] <= 299): - (code,resp) = self.helo() - if not (200 <= code <= 299): - raise SMTPHeloError(code, resp) - esmtp_opts = [] - if self.does_esmtp: - # Hmmm? what's this? -ddm - # self.esmtp_features['7bit']="" - if self.has_extn('size'): - esmtp_opts.append("size=" + `len(msg)`) - for option in mail_options: - esmtp_opts.append(option) - - (code,resp) = self.mail(from_addr, esmtp_opts) - if code <> 250: - self.rset() - raise SMTPSenderRefused(code, resp, from_addr) - senderrs={} - if type(to_addrs) == types.StringType: - to_addrs = [to_addrs] - for each in to_addrs: - (code,resp)=self.rcpt(each, rcpt_options) - if (code <> 250) and (code <> 251): - senderrs[each]=(code,resp) - if len(senderrs)==len(to_addrs): - # the server refused all our recipients - self.rset() - raise SMTPRecipientsRefused(senderrs) - (code,resp)=self.data(msg) - if code <> 250: - self.rset() - raise SMTPDataError(code, resp) - #if we got here then somebody got our mail - return senderrs - - - def close(self): - """Close the connection to the SMTP server.""" - if self.file: - self.file.close() - self.file = None - if self.sock: - self.sock.close() - self.sock = None - - - def quit(self): - """Terminate the SMTP session.""" - self.docmd("quit") - self.close() - - -# Test the sendmail method, which tests most of the others. -# Note: This always sends to localhost. -if __name__ == '__main__': - import sys, rfc822 - - def prompt(prompt): - sys.stdout.write(prompt + ": ") - return string.strip(sys.stdin.readline()) - - fromaddr = prompt("From") - toaddrs = string.splitfields(prompt("To"), ',') - print "Enter message, end with ^D:" - msg = '' - while 1: - line = sys.stdin.readline() - if not line: - break - msg = msg + line - print "Message length is " + `len(msg)` - - server = SMTP('localhost') - server.set_debuglevel(1) - server.sendmail(fromaddr, toaddrs, msg) - server.quit() diff --git a/Mailman/pythonlib/tempfile.py b/Mailman/pythonlib/tempfile.py deleted file mode 100644 index 7c59eb6a5..000000000 --- a/Mailman/pythonlib/tempfile.py +++ /dev/null @@ -1,146 +0,0 @@ -# Temporary file name allocation -# -# XXX This tries to be not UNIX specific, but I don't know beans about -# how to choose a temp directory or filename on MS-DOS or other -# systems so it may have to be changed... - - -import os - - -# Parameters that the caller may set to override the defaults - -tempdir = None -template = None - - -# Function to calculate the directory to use - -def gettempdir(): - global tempdir - if tempdir is not None: - return tempdir - try: - pwd = os.getcwd() - except (AttributeError, os.error): - pwd = os.curdir - attempdirs = ['/usr/tmp', '/tmp', pwd] - if os.name == 'nt': - attempdirs.insert(0, 'C:\\TEMP') - attempdirs.insert(0, '\\TEMP') - elif os.name == 'mac': - import macfs, MACFS - try: - refnum, dirid = macfs.FindFolder(MACFS.kOnSystemDisk, - MACFS.kTemporaryFolderType, 1) - dirname = macfs.FSSpec((refnum, dirid, '')).as_pathname() - attempdirs.insert(0, dirname) - except macfs.error: - pass - for envname in 'TMPDIR', 'TEMP', 'TMP': - if os.environ.has_key(envname): - attempdirs.insert(0, os.environ[envname]) - testfile = gettempprefix() + 'test' - for dir in attempdirs: - try: - filename = os.path.join(dir, testfile) - fp = open(filename, 'w') - fp.write('blat') - fp.close() - os.unlink(filename) - tempdir = dir - break - except IOError: - pass - if tempdir is None: - msg = "Can't find a usable temporary directory amongst " + `attempdirs` - raise IOError, msg - return tempdir - - -# Function to calculate a prefix of the filename to use - -_pid = None - -def gettempprefix(): - global template, _pid - if os.name == 'posix' and _pid and _pid != os.getpid(): - # Our pid changed; we must have forked -- zap the template - template = None - if template is None: - if os.name == 'posix': - _pid = os.getpid() - template = '@' + `_pid` + '.' - elif os.name == 'nt': - template = '~' + `os.getpid()` + '-' - elif os.name == 'mac': - template = 'Python-Tmp-' - else: - template = 'tmp' # XXX might choose a better one - return template - - -# Counter for generating unique names - -counter = 0 - - -# User-callable function to return a unique temporary file name - -def mktemp(suffix=""): - global counter - dir = gettempdir() - pre = gettempprefix() - while 1: - counter = counter + 1 - file = os.path.join(dir, pre + `counter` + suffix) - if not os.path.exists(file): - return file - - -class TemporaryFileWrapper: - """Temporary file wrapper - - This class provides a wrapper around files opened for temporary use. - In particular, it seeks to automatically remove the file when it is - no longer needed. - """ - def __init__(self, file, path): - self.file = file - self.path = path - - def close(self): - self.file.close() - os.unlink(self.path) - - def __del__(self): - try: self.close() - except: pass - - def __getattr__(self, name): - file = self.__dict__['file'] - a = getattr(file, name) - setattr(self, name, a) - return a - - -def TemporaryFile(mode='w+b', bufsize=-1, suffix=""): - name = mktemp(suffix) - if os.name == 'posix': - # Unix -- be very careful - fd = os.open(name, os.O_RDWR|os.O_CREAT|os.O_EXCL, 0700) - try: - os.unlink(name) - return os.fdopen(fd, mode, bufsize) - except: - os.close(fd) - # this is a divergence from the Python 1.5.2 copy. Mailman can't - # guarantee that Python 1.5.1 or better is being used, and Python - # 1.5 doesn't have bare raise. - import sys - t, v, tb = sys.exc_info() - raise t, v, tb - else: - # Non-unix -- can't unlink file that's still open, use wrapper - file = open(name, mode, bufsize) - return TemporaryFileWrapper(file, name) |