gdata.tlslite.integration.SMTP_TLS | index /usr/local/google/home/afshar/src/external-gdata-release/google3/src/gdata/tlslite/integration/SMTP_TLS.py

`TLS Lite + smtplib.`

Classes

``

smtplib.SMTP
  SMTP_TLS

class SMTP_TLS(smtplib.SMTP)
`` | `This class extends L{smtplib.SMTP} with TLS support.`

Methods defined here:

starttls(self, username=None, password=None, sharedKey=None, certChain=None, privateKey=None, cryptoID=None, protocol=None, x509Fingerprint=None, x509TrustList=None, x509CommonName=None, settings=None)
  `Puts the connection to the SMTP server into TLS mode.
  If the server supports TLS, this will encrypt the rest of the SMTP
  session.
  For client authentication, use one of these argument
  combinations:
  - username, password (SRP)
  - username, sharedKey (shared-key)
  - certChain, privateKey (certificate)
  For server authentication, you can either rely on the
  implicit mutual authentication performed by SRP or
  shared-keys, or you can do certificate-based server
  authentication with one of these argument combinations:
  - cryptoID[, protocol] (requires cryptoIDlib)
  - x509Fingerprint
  - x509TrustList[, x509CommonName] (requires cryptlib_py)
  Certificate-based server authentication is compatible with
  SRP or certificate-based client authentication. It is
  not compatible with shared-keys.
  The caller should be prepared to handle TLS-specific
  exceptions. See the client handshake functions in
  L{tlslite.TLSConnection.TLSConnection} for details on which
  exceptions might be raised.
  @type username: str
  @param username: SRP or shared-key username. Requires the
  'password' or 'sharedKey' argument.
  @type password: str
  @param password: SRP password for mutual authentication.
  Requires the 'username' argument.
  @type sharedKey: str
  @param sharedKey: Shared key for mutual authentication.
  Requires the 'username' argument.
  @type certChain: L{tlslite.X509CertChain.X509CertChain} or
  L{cryptoIDlib.CertChain.CertChain}
  @param certChain: Certificate chain for client authentication.
  Requires the 'privateKey' argument. Excludes the SRP or
  shared-key related arguments.
  @type privateKey: L{tlslite.utils.RSAKey.RSAKey}
  @param privateKey: Private key for client authentication.
  Requires the 'certChain' argument. Excludes the SRP or
  shared-key related arguments.
  @type cryptoID: str
  @param cryptoID: cryptoID for server authentication. Mutually
  exclusive with the 'x509...' arguments.
  @type protocol: str
  @param protocol: cryptoID protocol URI for server
  authentication. Requires the 'cryptoID' argument.
  @type x509Fingerprint: str
  @param x509Fingerprint: Hex-encoded X.509 fingerprint for
  server authentication. Mutually exclusive with the 'cryptoID'
  and 'x509TrustList' arguments.
  @type x509TrustList: list of L{tlslite.X509.X509}
  @param x509TrustList: A list of trusted root certificates. The
  other party must present a certificate chain which extends to
  one of these root certificates. The cryptlib_py module must be
  installed to use this parameter. Mutually exclusive with the
  'cryptoID' and 'x509Fingerprint' arguments.
  @type x509CommonName: str
  @param x509CommonName: The end-entity certificate's 'CN' field
  must match this value. For a web server, this is typically a
  server name such as 'www.amazon.com'. Mutually exclusive with
  the 'cryptoID' and 'x509Fingerprint' arguments. Requires the
  'x509TrustList' argument.
  @type settings: L{tlslite.HandshakeSettings.HandshakeSettings}
  @param settings: Various settings which can be used to control
  the ciphersuites, certificate types, and SSL/TLS versions
  offered by the client.`

Methods inherited from smtplib.SMTP:

__init__(self, host='', port=0, local_hostname=None, timeout=<object object>)
  `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. If specified,
  `local_hostname` is used as the FQDN of the local host. By default,
  the local hostname is found using socket.getfqdn().`

close(self)
  `Close the connection to the SMTP server.`

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.`

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.`

docmd(self, cmd, args='')
  `Send a command, and return its response code.`

ehlo(self, name='')
  `SMTP 'ehlo' command.
  Hostname to send for this command defaults to the FQDN of the local
  host.`

ehlo_or_helo_if_needed(self)
  `Call ehlo() and/or helo() if needed.
  If there has been no previous EHLO or HELO command this session, this
  method tries ESMTP EHLO first.
  This method may raise the following exceptions:
  SMTPHeloError The server didn't reply properly to
  the helo greeting.`

expn(self, address)
  `SMTP 'expn' command -- expands a mailing list.`

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.`

has_extn(self, opt)
  `Does the server support a given SMTP service extension?`

helo(self, name='')
  `SMTP 'helo' command.
  Hostname to send for this command defaults to the FQDN of the local
  host.`

help(self, args='')
  `SMTP 'help' command.
  Returns help text from server.`

login(self, user, password)
  `Log in on an SMTP server that requires authentication.
  The arguments are:
  - user: The user name to authenticate with.
  - password: The password for the authentication.
  If there has been no previous EHLO or HELO command this session, this
  method tries ESMTP EHLO first.
  This method will return normally if the authentication was successful.
  This method may raise the following exceptions:
  SMTPHeloError The server didn't reply properly to
  the helo greeting.
  SMTPAuthenticationError The server didn't accept the username/
  password combination.
  SMTPException No suitable authentication method was
  found.`

mail(self, sender, options=[])
  `SMTP 'mail' command -- begins mail xfer session.`

noop(self)
  `SMTP 'noop' command -- doesn't do anything :>`

putcmd(self, cmd, args='')
  `Send a command to the server.`

quit(self)
  `Terminate the SMTP session.`

rcpt(self, recip, options=[])
  `SMTP 'rcpt' command -- indicates 1 recipient for this mail.`

rset(self)
  `SMTP 'rset' command -- resets session.`

send(self, str)
  `Send `str' to the server.`

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.`

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.`

verify(self, address)
  `SMTP 'verify' command -- checks for address validity.`

vrfy = verify(self, address)
  `SMTP 'verify' command -- checks for address validity.`

Data and other attributes inherited from smtplib.SMTP:

debuglevel = 0

default_port = 25

does_esmtp = 0

ehlo_msg = 'ehlo'

ehlo_resp = None

file = None

helo_resp = None