Lib/smtplib.py

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