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 / smtplib.py < prev    next >
Text File  |  2000-12-21  |  19KB  |  541 lines
  1. #! /usr/bin/env python
  2.  
  3. """SMTP/ESMTP client class.
  4.  
  5. This should follow RFC 821 (SMTP) and RFC 1869 (ESMTP).
  6.  
  7. Notes:
  8.  
  9. Please remember, when doing ESMTP, that the names of the SMTP service
  10. extensions are NOT the same thing as the option keywords for the RCPT
  11. and MAIL commands!
  12.  
  13. Example:
  14.  
  15.   >>> import smtplib
  16.   >>> s=smtplib.SMTP("localhost")
  17.   >>> print s.help()
  18.   This is Sendmail version 8.8.4
  19.   Topics:
  20.       HELO    EHLO    MAIL    RCPT    DATA
  21.       RSET    NOOP    QUIT    HELP    VRFY
  22.       EXPN    VERB    ETRN    DSN
  23.   For more info use "HELP <topic>".
  24.   To report bugs in the implementation send email to
  25.       sendmail-bugs@sendmail.org.
  26.   For local information send email to Postmaster at your site.
  27.   End of HELP info
  28.   >>> s.putcmd("vrfy","someone@here")
  29.   >>> s.getreply()
  30.   (250, "Somebody OverHere <somebody@here.my.org>")
  31.   >>> s.quit()
  32. """
  33.  
  34. # Author: The Dragon De Monsyne <dragondm@integral.org>
  35. # ESMTP support, test code and doc fixes added by
  36. #     Eric S. Raymond <esr@thyrsus.com>
  37. # Better RFC 821 compliance (MAIL and RCPT, and CRLF in data)
  38. #     by Carey Evans <c.evans@clear.net.nz>, for picky mail servers.
  39. #    
  40. # This was modified from the Python 1.5 library HTTP lib.
  41.  
  42. import socket
  43. import string
  44. import re
  45. import rfc822
  46. import types
  47.  
  48. SMTP_PORT = 25
  49. CRLF="\r\n"
  50.  
  51. # Exception classes used by this module. 
  52. class SMTPException(Exception):
  53.     """Base class for all exceptions raised by this module."""
  54.  
  55. class SMTPServerDisconnected(SMTPException):
  56.     """Not connected to any SMTP server.
  57.  
  58.     This exception is raised when the server unexpectedly disconnects,
  59.     or when an attempt is made to use the SMTP instance before
  60.     connecting it to a server.
  61.     """
  62.  
  63. class SMTPResponseException(SMTPException):
  64.     """Base class for all exceptions that include an SMTP error code.
  65.  
  66.     These exceptions are generated in some instances when the SMTP
  67.     server returns an error code.  The error code is stored in the
  68.     `smtp_code' attribute of the error, and the `smtp_error' attribute
  69.     is set to the error message.
  70.     """
  71.  
  72.     def __init__(self, code, msg):
  73.         self.smtp_code = code
  74.         self.smtp_error = msg
  75.         self.args = (code, msg)
  76.  
  77. class SMTPSenderRefused(SMTPResponseException):
  78.     """Sender address refused.
  79.     In addition to the attributes set by on all SMTPResponseException
  80.     exceptions, this sets `sender' to the string that the SMTP refused.
  81.     """
  82.  
  83.     def __init__(self, code, msg, sender):
  84.         self.smtp_code = code
  85.         self.smtp_error = msg
  86.         self.sender = sender
  87.         self.args = (code, msg, sender)
  88.  
  89. class SMTPRecipientsRefused(SMTPException):
  90.     """All recipient addresses refused.
  91.     The errors for each recipient are accessable thru the attribute
  92.     'recipients', which is a dictionary of exactly the same sort as 
  93.     SMTP.sendmail() returns.  
  94.     """
  95.  
  96.     def __init__(self, recipients):
  97.         self.recipients = recipients
  98.         self.args = ( recipients,)
  99.  
  100.  
  101.  
  102. class SMTPDataError(SMTPResponseException):
  103.     """The SMTP server didn't accept the data."""
  104.  
  105. class SMTPConnectError(SMTPResponseException):
  106.     """Error during connection establishment."""
  107.  
  108. class SMTPHeloError(SMTPResponseException):
  109.     """The server refused our HELO reply."""
  110.  
  111. def quoteaddr(addr):
  112.     """Quote a subset of the email addresses defined by RFC 821.
  113.  
  114.     Should be able to handle anything rfc822.parseaddr can handle.
  115.     """
  116.     m=None
  117.     try:
  118.         m=rfc822.parseaddr(addr)[1]
  119.     except AttributeError:
  120.         pass
  121.     if not m:
  122.         #something weird here.. punt -ddm
  123.         return addr
  124.     else:
  125.         return "<%s>" % m
  126.  
  127. def quotedata(data):
  128.     """Quote data for email.
  129.  
  130.     Double leading '.', and change Unix newline '\\n', or Mac '\\r' into
  131.     Internet CRLF end-of-line.
  132.     """
  133.     return re.sub(r'(?m)^\.', '..',
  134.         re.sub(r'(?:\r\n|\n|\r(?!\n))', CRLF, data))
  135.  
  136. class SMTP:
  137.     """This class manages a connection to an SMTP or ESMTP server.
  138.     SMTP Objects:
  139.         SMTP objects have the following attributes:    
  140.             helo_resp 
  141.                 This is the message given by the server in response to the 
  142.                 most recent HELO command.
  143.                 
  144.             ehlo_resp
  145.                 This is the message given by the server in response to the 
  146.                 most recent EHLO command. This is usually multiline.
  147.  
  148.             does_esmtp 
  149.                 This is a True value _after you do an EHLO command_, if the
  150.                 server supports ESMTP.
  151.  
  152.             esmtp_features 
  153.                 This is a dictionary, which, if the server supports ESMTP,
  154.                 will _after you do an EHLO command_, contain the names of the
  155.                 SMTP service extensions this server supports, and their
  156.                 parameters (if any).
  157.  
  158.                 Note, all extension names are mapped to lower case in the 
  159.                 dictionary. 
  160.  
  161.         See each method's docstrings for details.  In general, there is a
  162.         method of the same name to perform each SMTP command.  There is also a
  163.         method called 'sendmail' that will do an entire mail transaction.
  164.         """
  165.     debuglevel = 0
  166.     file = None
  167.     helo_resp = None
  168.     ehlo_resp = None
  169.     does_esmtp = 0
  170.  
  171.     def __init__(self, host = '', port = 0):
  172.         """Initialize a new instance.
  173.  
  174.         If specified, `host' is the name of the remote host to which to
  175.         connect.  If specified, `port' specifies the port to which to connect.
  176.         By default, smtplib.SMTP_PORT is used.  An SMTPConnectError is raised
  177.         if the specified `host' doesn't respond correctly.
  178.  
  179.         """
  180.         self.esmtp_features = {}
  181.         if host:
  182.             (code, msg) = self.connect(host, port)
  183.             if code != 220:
  184.                 raise SMTPConnectError(code, msg)
  185.     
  186.     def set_debuglevel(self, debuglevel):
  187.         """Set the debug output level.
  188.  
  189.         A non-false value results in debug messages for connection and for all
  190.         messages sent to and received from the server.
  191.  
  192.         """
  193.         self.debuglevel = debuglevel
  194.  
  195.     def connect(self, host='localhost', port = 0):
  196.         """Connect to a host on a given port.
  197.  
  198.         If the hostname ends with a colon (`:') followed by a number, and
  199.         there is no port specified, that suffix will be stripped off and the
  200.         number interpreted as the port number to use.
  201.  
  202.         Note: This method is automatically invoked by __init__, if a host is
  203.         specified during instantiation.
  204.  
  205.         """
  206.         if not port:
  207.             i = string.find(host, ':')
  208.             if i >= 0:
  209.                 host, port = host[:i], host[i+1:]
  210.                 try: port = string.atoi(port)
  211.                 except string.atoi_error:
  212.                     raise socket.error, "nonnumeric port"
  213.         if not port: port = SMTP_PORT
  214.         self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
  215.         if self.debuglevel > 0: print 'connect:', (host, port)
  216.         self.sock.connect(host, port)
  217.         (code,msg)=self.getreply()
  218.         if self.debuglevel >0 : print "connect:", msg
  219.         return (code,msg)
  220.     
  221.     def send(self, str):
  222.         """Send `str' to the server."""
  223.         if self.debuglevel > 0: print 'send:', `str`
  224.         if self.sock:
  225.             try:
  226.                 self.sock.send(str)
  227.             except socket.error:
  228.                 raise SMTPServerDisconnected('Server not connected')
  229.         else:
  230.             raise SMTPServerDisconnected('please run connect() first')
  231.  
  232.     def putcmd(self, cmd, args=""):
  233.         """Send a command to the server."""
  234.         if args == "":
  235.             str = '%s%s' % (cmd, CRLF)
  236.         else:
  237.             str = '%s %s%s' % (cmd, args, CRLF)
  238.         self.send(str)
  239.     
  240.     def getreply(self):
  241.         """Get a reply from the server.
  242.         
  243.         Returns a tuple consisting of:
  244.  
  245.           - server response code (e.g. '250', or such, if all goes well)
  246.             Note: returns -1 if it can't read response code.
  247.  
  248.           - server response string corresponding to response code (multiline
  249.             responses are converted to a single, multiline string).
  250.  
  251.         Raises SMTPServerDisconnected if end-of-file is reached.
  252.         """
  253.         resp=[]
  254.         if self.file is None:
  255.             self.file = self.sock.makefile('rb')
  256.         while 1:
  257.             line = self.file.readline()
  258.             if line == '':
  259.                 self.close()
  260.                 raise SMTPServerDisconnected("Connection unexpectedly closed")
  261.             if self.debuglevel > 0: print 'reply:', `line`
  262.             resp.append(string.strip(line[4:]))
  263.             code=line[:3]
  264.             # Check that the error code is syntactically correct.
  265.             # Don't attempt to read a continuation line if it is broken.
  266.             try:
  267.                 errcode = string.atoi(code)
  268.             except ValueError:
  269.                 errcode = -1
  270.                 break
  271.             # Check if multiline response.
  272.             if line[3:4]!="-":
  273.                 break
  274.  
  275.         errmsg = string.join(resp,"\n")
  276.         if self.debuglevel > 0: 
  277.             print 'reply: retcode (%s); Msg: %s' % (errcode,errmsg)
  278.         return errcode, errmsg
  279.     
  280.     def docmd(self, cmd, args=""):
  281.         """Send a command, and return its response code."""
  282.         self.putcmd(cmd,args)
  283.         return self.getreply()
  284.  
  285.     # std smtp commands
  286.     def helo(self, name=''):
  287.         """SMTP 'helo' command.
  288.         Hostname to send for this command defaults to the FQDN of the local
  289.         host.
  290.         """
  291.         name=string.strip(name)
  292.         if len(name)==0:
  293.             name = socket.gethostname()
  294.             try:
  295.                 name = socket.gethostbyaddr(name)[0]
  296.             except socket.error:
  297.                 pass
  298.         self.putcmd("helo",name)
  299.         (code,msg)=self.getreply()
  300.         self.helo_resp=msg
  301.         return (code,msg)
  302.  
  303.     def ehlo(self, name=''):
  304.         """ SMTP 'ehlo' command.
  305.         Hostname to send for this command defaults to the FQDN of the local
  306.         host.
  307.         """
  308.         name=string.strip(name)
  309.         if len(name)==0:
  310.             name = socket.gethostname()
  311.             try:
  312.                 name = socket.gethostbyaddr(name)[0]
  313.             except socket.error:
  314.                 pass
  315.         self.putcmd("ehlo",name)
  316.         (code,msg)=self.getreply()
  317.         # According to RFC1869 some (badly written) 
  318.         # MTA's will disconnect on an ehlo. Toss an exception if 
  319.         # that happens -ddm
  320.         if code == -1 and len(msg) == 0:
  321.             raise SMTPServerDisconnected("Server not connected")
  322.         self.ehlo_resp=msg
  323.         if code<>250:
  324.             return (code,msg)
  325.         self.does_esmtp=1
  326.         #parse the ehlo responce -ddm
  327.         resp=string.split(self.ehlo_resp,'\n')
  328.         del resp[0]
  329.         for each in resp:
  330.             m=re.match(r'(?P<feature>[A-Za-z0-9][A-Za-z0-9\-]*)',each)
  331.             if m:
  332.                 feature=string.lower(m.group("feature"))
  333.                 params=string.strip(m.string[m.end("feature"):])
  334.                 self.esmtp_features[feature]=params
  335.         return (code,msg)
  336.  
  337.     def has_extn(self, opt):
  338.         """Does the server support a given SMTP service extension?"""
  339.         return self.esmtp_features.has_key(string.lower(opt))
  340.  
  341.     def help(self, args=''):
  342.         """SMTP 'help' command.
  343.         Returns help text from server."""
  344.         self.putcmd("help", args)
  345.         return self.getreply()
  346.  
  347.     def rset(self):
  348.         """SMTP 'rset' command -- resets session."""
  349.         return self.docmd("rset")
  350.  
  351.     def noop(self):
  352.         """SMTP 'noop' command -- doesn't do anything :>"""
  353.         return self.docmd("noop")
  354.  
  355.     def mail(self,sender,options=[]):
  356.         """SMTP 'mail' command -- begins mail xfer session."""
  357.         optionlist = ''
  358.         if options and self.does_esmtp:
  359.             optionlist = ' ' + string.join(options, ' ')
  360.         self.putcmd("mail", "FROM:%s%s" % (quoteaddr(sender) ,optionlist))
  361.         return self.getreply()
  362.  
  363.     def rcpt(self,recip,options=[]):
  364.         """SMTP 'rcpt' command -- indicates 1 recipient for this mail."""
  365.         optionlist = ''
  366.         if options and self.does_esmtp:
  367.             optionlist = ' ' + string.join(options, ' ')
  368.         self.putcmd("rcpt","TO:%s%s" % (quoteaddr(recip),optionlist))
  369.         return self.getreply()
  370.  
  371.     def data(self,msg):
  372.         """SMTP 'DATA' command -- sends message data to server. 
  373.  
  374.         Automatically quotes lines beginning with a period per rfc821.
  375.         Raises SMTPDataError if there is an unexpected reply to the
  376.         DATA command; the return value from this method is the final
  377.         response code received when the all data is sent.
  378.         """
  379.         self.putcmd("data")
  380.         (code,repl)=self.getreply()
  381.         if self.debuglevel >0 : print "data:", (code,repl)
  382.         if code <> 354:
  383.             raise SMTPDataError(code,repl)
  384.         else:
  385.             q = quotedata(msg)
  386.             if q[-2:] != CRLF:
  387.                 q = q + CRLF
  388.             q = q + "." + CRLF
  389.             self.send(q)
  390.             (code,msg)=self.getreply()
  391.             if self.debuglevel >0 : print "data:", (code,msg)
  392.             return (code,msg)
  393.  
  394.     def verify(self, address):
  395.         """SMTP 'verify' command -- checks for address validity."""
  396.         self.putcmd("vrfy", quoteaddr(address))
  397.         return self.getreply()
  398.     # a.k.a.
  399.     vrfy=verify
  400.  
  401.     def expn(self, address):
  402.         """SMTP 'verify' command -- checks for address validity."""
  403.         self.putcmd("expn", quoteaddr(address))
  404.         return self.getreply()
  405.  
  406.     # some useful methods
  407.     def sendmail(self, from_addr, to_addrs, msg, mail_options=[],
  408.                  rcpt_options=[]): 
  409.         """This command performs an entire mail transaction. 
  410.  
  411.         The arguments are: 
  412.             - from_addr    : The address sending this mail.
  413.             - to_addrs     : A list of addresses to send this mail to.  A bare
  414.                              string will be treated as a list with 1 address.
  415.             - msg          : The message to send. 
  416.             - mail_options : List of ESMTP options (such as 8bitmime) for the
  417.                              mail command.
  418.             - rcpt_options : List of ESMTP options (such as DSN commands) for
  419.                              all the rcpt commands.
  420.  
  421.         If there has been no previous EHLO or HELO command this session, this
  422.         method tries ESMTP EHLO first.  If the server does ESMTP, message size
  423.         and each of the specified options will be passed to it.  If EHLO
  424.         fails, HELO will be tried and ESMTP options suppressed.
  425.  
  426.         This method will return normally if the mail is accepted for at least
  427.         one recipient.  It returns a dictionary, with one entry for each
  428.         recipient that was refused.  Each entry contains a tuple of the SMTP
  429.         error code and the accompanying error message sent by the server.
  430.  
  431.         This method may raise the following exceptions:
  432.  
  433.          SMTPHeloError          The server didn't reply properly to
  434.                                 the helo greeting. 
  435.          SMTPRecipientsRefused  The server rejected ALL recipients
  436.                                 (no mail was sent).
  437.          SMTPSenderRefused      The server didn't accept the from_addr.
  438.          SMTPDataError          The server replied with an unexpected
  439.                                 error code (other than a refusal of
  440.                                 a recipient).
  441.  
  442.         Note: the connection will be open even after an exception is raised.
  443.  
  444.         Example:
  445.       
  446.          >>> import smtplib
  447.          >>> s=smtplib.SMTP("localhost")
  448.          >>> tolist=["one@one.org","two@two.org","three@three.org","four@four.org"]
  449.          >>> msg = '''
  450.          ... From: Me@my.org
  451.          ... Subject: testin'...
  452.          ...
  453.          ... This is a test '''
  454.          >>> s.sendmail("me@my.org",tolist,msg)
  455.          { "three@three.org" : ( 550 ,"User unknown" ) }
  456.          >>> s.quit()
  457.         
  458.         In the above example, the message was accepted for delivery to three
  459.         of the four addresses, and one was rejected, with the error code
  460.         550.  If all addresses are accepted, then the method will return an
  461.         empty dictionary.
  462.  
  463.         """
  464.         if self.helo_resp is None and self.ehlo_resp is None:
  465.             if not (200 <= self.ehlo()[0] <= 299):
  466.                 (code,resp) = self.helo()
  467.                 if not (200 <= code <= 299):
  468.                     raise SMTPHeloError(code, resp)
  469.         esmtp_opts = []
  470.         if self.does_esmtp:
  471.             # Hmmm? what's this? -ddm
  472.             # self.esmtp_features['7bit']=""
  473.             if self.has_extn('size'):
  474.                 esmtp_opts.append("size=" + `len(msg)`)
  475.             for option in mail_options:
  476.                 esmtp_opts.append(option)
  477.  
  478.         (code,resp) = self.mail(from_addr, esmtp_opts)
  479.         if code <> 250:
  480.             self.rset()
  481.             raise SMTPSenderRefused(code, resp, from_addr)
  482.         senderrs={}
  483.         if type(to_addrs) == types.StringType:
  484.             to_addrs = [to_addrs]
  485.         for each in to_addrs:
  486.             (code,resp)=self.rcpt(each, rcpt_options)
  487.             if (code <> 250) and (code <> 251):
  488.                 senderrs[each]=(code,resp)
  489.         if len(senderrs)==len(to_addrs):
  490.             # the server refused all our recipients
  491.             self.rset()
  492.             raise SMTPRecipientsRefused(senderrs)
  493.         (code,resp)=self.data(msg)
  494.         if code <> 250:
  495.             self.rset()
  496.             raise SMTPDataError(code, resp)
  497.         #if we got here then somebody got our mail
  498.         return senderrs         
  499.  
  500.  
  501.     def close(self):
  502.         """Close the connection to the SMTP server."""
  503.         if self.file:
  504.             self.file.close()
  505.         self.file = None
  506.         if self.sock:
  507.             self.sock.close()
  508.         self.sock = None
  509.  
  510.  
  511.     def quit(self):
  512.         """Terminate the SMTP session."""
  513.         self.docmd("quit")
  514.         self.close()
  515.  
  516.  
  517. # Test the sendmail method, which tests most of the others.
  518. # Note: This always sends to localhost.
  519. if __name__ == '__main__':
  520.     import sys, rfc822
  521.  
  522.     def prompt(prompt):
  523.         sys.stdout.write(prompt + ": ")
  524.         return string.strip(sys.stdin.readline())
  525.  
  526.     fromaddr = prompt("From")
  527.     toaddrs  = string.splitfields(prompt("To"), ',')
  528.     print "Enter message, end with ^D:"
  529.     msg = ''
  530.     while 1:
  531.         line = sys.stdin.readline()
  532.         if not line:
  533.             break
  534.         msg = msg + line
  535.     print "Message length is " + `len(msg)`
  536.  
  537.     server = SMTP('localhost')
  538.     server.set_debuglevel(1)
  539.     server.sendmail(fromaddr, toaddrs, msg)
  540.     server.quit()
  541.