Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(102)

Unified Diff: third_party/twisted_8_1/twisted/mail/pop3client.py

Issue 12261012: Remove third_party/twisted_8_1 (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/tools/build
Patch Set: Created 7 years, 10 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « third_party/twisted_8_1/twisted/mail/pop3.py ('k') | third_party/twisted_8_1/twisted/mail/protocols.py » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: third_party/twisted_8_1/twisted/mail/pop3client.py
diff --git a/third_party/twisted_8_1/twisted/mail/pop3client.py b/third_party/twisted_8_1/twisted/mail/pop3client.py
deleted file mode 100644
index 5b7986c99d62617baac11d141370195ea01f02a8..0000000000000000000000000000000000000000
--- a/third_party/twisted_8_1/twisted/mail/pop3client.py
+++ /dev/null
@@ -1,704 +0,0 @@
-# -*- test-case-name: twisted.mail.test.test_pop3client -*-
-# Copyright (c) 2001-2004 Divmod Inc.
-# See LICENSE for details.
-
-"""
-POP3 client protocol implementation
-
-Don't use this module directly. Use twisted.mail.pop3 instead.
-
-@author: U{Jp Calderone<mailto:exarkun@twistedmatrix.com>}
-"""
-
-import re, md5
-
-from twisted.python import log
-from twisted.internet import defer
-from twisted.protocols import basic
-from twisted.protocols import policies
-from twisted.internet import error
-from twisted.internet import interfaces
-
-OK = '+OK'
-ERR = '-ERR'
-
-class POP3ClientError(Exception):
- """Base class for all exceptions raised by POP3Client.
- """
-
-class InsecureAuthenticationDisallowed(POP3ClientError):
- """Secure authentication was required but no mechanism could be found.
- """
-
-class TLSError(POP3ClientError):
- """
- Secure authentication was required but either the transport does
- not support TLS or no TLS context factory was supplied.
- """
-
-class TLSNotSupportedError(POP3ClientError):
- """
- Secure authentication was required but the server does not support
- TLS.
- """
-
-class ServerErrorResponse(POP3ClientError):
- """The server returned an error response to a request.
- """
- def __init__(self, reason, consumer=None):
- POP3ClientError.__init__(self, reason)
- self.consumer = consumer
-
-class LineTooLong(POP3ClientError):
- """The server sent an extremely long line.
- """
-
-class _ListSetter:
- # Internal helper. POP3 responses sometimes occur in the
- # form of a list of lines containing two pieces of data,
- # a message index and a value of some sort. When a message
- # is deleted, it is omitted from these responses. The
- # setitem method of this class is meant to be called with
- # these two values. In the cases where indexes are skipped,
- # it takes care of padding out the missing values with None.
- def __init__(self, L):
- self.L = L
- def setitem(self, (item, value)):
- diff = item - len(self.L) + 1
- if diff > 0:
- self.L.extend([None] * diff)
- self.L[item] = value
-
-
-def _statXform(line):
- # Parse a STAT response
- numMsgs, totalSize = line.split(None, 1)
- return int(numMsgs), int(totalSize)
-
-
-def _listXform(line):
- # Parse a LIST response
- index, size = line.split(None, 1)
- return int(index) - 1, int(size)
-
-
-def _uidXform(line):
- # Parse a UIDL response
- index, uid = line.split(None, 1)
- return int(index) - 1, uid
-
-def _codeStatusSplit(line):
- # Parse an +OK or -ERR response
- parts = line.split(' ', 1)
- if len(parts) == 1:
- return parts[0], ''
- return parts
-
-def _dotUnquoter(line):
- """
- C{'.'} characters which begin a line of a message are doubled to avoid
- confusing with the terminating C{'.\\r\\n'} sequence. This function
- unquotes them.
- """
- if line.startswith('..'):
- return line[1:]
- return line
-
-class POP3Client(basic.LineOnlyReceiver, policies.TimeoutMixin):
- """POP3 client protocol implementation class
-
- Instances of this class provide a convenient, efficient API for
- retrieving and deleting messages from a POP3 server.
-
- @type startedTLS: C{bool}
- @ivar startedTLS: Whether TLS has been negotiated successfully.
-
-
- @type allowInsecureLogin: C{bool}
- @ivar allowInsecureLogin: Indicate whether login() should be
- allowed if the server offers no authentication challenge and if
- our transport does not offer any protection via encryption.
-
- @type serverChallenge: C{str} or C{None}
- @ivar serverChallenge: Challenge received from the server
-
- @type timeout: C{int}
- @ivar timeout: Number of seconds to wait before timing out a
- connection. If the number is <= 0, no timeout checking will be
- performed.
- """
-
- startedTLS = False
- allowInsecureLogin = False
- timeout = 0
- serverChallenge = None
-
- # Capabilities are not allowed to change during the session
- # (except when TLS is negotiated), so cache the first response and
- # use that for all later lookups
- _capCache = None
-
- # Regular expression to search for in the challenge string in the server
- # greeting line.
- _challengeMagicRe = re.compile('(<[^>]+>)')
-
- # List of pending calls.
- # We are a pipelining API but don't actually
- # support pipelining on the network yet.
- _blockedQueue = None
-
- # The Deferred to which the very next result will go.
- _waiting = None
-
- # Whether we dropped the connection because of a timeout
- _timedOut = False
-
- # If the server sends an initial -ERR, this is the message it sent
- # with it.
- _greetingError = None
-
- def _blocked(self, f, *a):
- # Internal helper. If commands are being blocked, append
- # the given command and arguments to a list and return a Deferred
- # that will be chained with the return value of the function
- # when it eventually runs. Otherwise, set up for commands to be
-
- # blocked and return None.
- if self._blockedQueue is not None:
- d = defer.Deferred()
- self._blockedQueue.append((d, f, a))
- return d
- self._blockedQueue = []
- return None
-
- def _unblock(self):
- # Internal helper. Indicate that a function has completed.
- # If there are blocked commands, run the next one. If there
- # are not, set up for the next command to not be blocked.
- if self._blockedQueue == []:
- self._blockedQueue = None
- elif self._blockedQueue is not None:
- _blockedQueue = self._blockedQueue
- self._blockedQueue = None
-
- d, f, a = _blockedQueue.pop(0)
- d2 = f(*a)
- d2.chainDeferred(d)
- # f is a function which uses _blocked (otherwise it wouldn't
- # have gotten into the blocked queue), which means it will have
- # re-set _blockedQueue to an empty list, so we can put the rest
- # of the blocked queue back into it now.
- self._blockedQueue.extend(_blockedQueue)
-
-
- def sendShort(self, cmd, args):
- # Internal helper. Send a command to which a short response
- # is expected. Return a Deferred that fires when the response
- # is received. Block all further commands from being sent until
- # the response is received. Transition the state to SHORT.
- d = self._blocked(self.sendShort, cmd, args)
- if d is not None:
- return d
-
- if args:
- self.sendLine(cmd + ' ' + args)
- else:
- self.sendLine(cmd)
- self.state = 'SHORT'
- self._waiting = defer.Deferred()
- return self._waiting
-
- def sendLong(self, cmd, args, consumer, xform):
- # Internal helper. Send a command to which a multiline
- # response is expected. Return a Deferred that fires when
- # the entire response is received. Block all further commands
- # from being sent until the entire response is received.
- # Transition the state to LONG_INITIAL.
- d = self._blocked(self.sendLong, cmd, args, consumer, xform)
- if d is not None:
- return d
-
- if args:
- self.sendLine(cmd + ' ' + args)
- else:
- self.sendLine(cmd)
- self.state = 'LONG_INITIAL'
- self._xform = xform
- self._consumer = consumer
- self._waiting = defer.Deferred()
- return self._waiting
-
- # Twisted protocol callback
- def connectionMade(self):
- if self.timeout > 0:
- self.setTimeout(self.timeout)
-
- self.state = 'WELCOME'
- self._blockedQueue = []
-
- def timeoutConnection(self):
- self._timedOut = True
- self.transport.loseConnection()
-
- def connectionLost(self, reason):
- if self.timeout > 0:
- self.setTimeout(None)
-
- if self._timedOut:
- reason = error.TimeoutError()
- elif self._greetingError:
- reason = ServerErrorResponse(self._greetingError)
-
- d = []
- if self._waiting is not None:
- d.append(self._waiting)
- self._waiting = None
- if self._blockedQueue is not None:
- d.extend([deferred for (deferred, f, a) in self._blockedQueue])
- self._blockedQueue = None
- for w in d:
- w.errback(reason)
-
- def lineReceived(self, line):
- if self.timeout > 0:
- self.resetTimeout()
-
- state = self.state
- self.state = None
- state = getattr(self, 'state_' + state)(line) or state
- if self.state is None:
- self.state = state
-
- def lineLengthExceeded(self, buffer):
- # XXX - We need to be smarter about this
- if self._waiting is not None:
- waiting, self._waiting = self._waiting, None
- waiting.errback(LineTooLong())
- self.transport.loseConnection()
-
- # POP3 Client state logic - don't touch this.
- def state_WELCOME(self, line):
- # WELCOME is the first state. The server sends one line of text
- # greeting us, possibly with an APOP challenge. Transition the
- # state to WAITING.
- code, status = _codeStatusSplit(line)
- if code != OK:
- self._greetingError = status
- self.transport.loseConnection()
- else:
- m = self._challengeMagicRe.search(status)
-
- if m is not None:
- self.serverChallenge = m.group(1)
-
- self.serverGreeting(status)
-
- self._unblock()
- return 'WAITING'
-
- def state_WAITING(self, line):
- # The server isn't supposed to send us anything in this state.
- log.msg("Illegal line from server: " + repr(line))
-
- def state_SHORT(self, line):
- # This is the state we are in when waiting for a single
- # line response. Parse it and fire the appropriate callback
- # or errback. Transition the state back to WAITING.
- deferred, self._waiting = self._waiting, None
- self._unblock()
- code, status = _codeStatusSplit(line)
- if code == OK:
- deferred.callback(status)
- else:
- deferred.errback(ServerErrorResponse(status))
- return 'WAITING'
-
- def state_LONG_INITIAL(self, line):
- # This is the state we are in when waiting for the first
- # line of a long response. Parse it and transition the
- # state to LONG if it is an okay response; if it is an
- # error response, fire an errback, clean up the things
- # waiting for a long response, and transition the state
- # to WAITING.
- code, status = _codeStatusSplit(line)
- if code == OK:
- return 'LONG'
- consumer = self._consumer
- deferred = self._waiting
- self._consumer = self._waiting = self._xform = None
- self._unblock()
- deferred.errback(ServerErrorResponse(status, consumer))
- return 'WAITING'
-
- def state_LONG(self, line):
- # This is the state for each line of a long response.
- # If it is the last line, finish things, fire the
- # Deferred, and transition the state to WAITING.
- # Otherwise, pass the line to the consumer.
- if line == '.':
- consumer = self._consumer
- deferred = self._waiting
- self._consumer = self._waiting = self._xform = None
- self._unblock()
- deferred.callback(consumer)
- return 'WAITING'
- else:
- if self._xform is not None:
- self._consumer(self._xform(line))
- else:
- self._consumer(line)
- return 'LONG'
-
-
- # Callbacks - override these
- def serverGreeting(self, greeting):
- """Called when the server has sent us a greeting.
-
- @type greeting: C{str} or C{None}
- @param greeting: The status message sent with the server
- greeting. For servers implementing APOP authentication, this
- will be a challenge string. .
- """
-
-
- # External API - call these (most of 'em anyway)
- def startTLS(self, contextFactory=None):
- """
- Initiates a 'STLS' request and negotiates the TLS / SSL
- Handshake.
-
- @type contextFactory: C{ssl.ClientContextFactory} @param
- contextFactory: The context factory with which to negotiate
- TLS. If C{None}, try to create a new one.
-
- @return: A Deferred which fires when the transport has been
- secured according to the given contextFactory, or which fails
- if the transport cannot be secured.
- """
- tls = interfaces.ITLSTransport(self.transport, None)
- if tls is None:
- return defer.fail(TLSError(
- "POP3Client transport does not implement "
- "interfaces.ITLSTransport"))
-
- if contextFactory is None:
- contextFactory = self._getContextFactory()
-
- if contextFactory is None:
- return defer.fail(TLSError(
- "POP3Client requires a TLS context to "
- "initiate the STLS handshake"))
-
- d = self.capabilities()
- d.addCallback(self._startTLS, contextFactory, tls)
- return d
-
-
- def _startTLS(self, caps, contextFactory, tls):
- assert not self.startedTLS, "Client and Server are currently communicating via TLS"
-
- if 'STLS' not in caps:
- return defer.fail(TLSNotSupportedError(
- "Server does not support secure communication "
- "via TLS / SSL"))
-
- d = self.sendShort('STLS', None)
- d.addCallback(self._startedTLS, contextFactory, tls)
- d.addCallback(lambda _: self.capabilities())
- return d
-
-
- def _startedTLS(self, result, context, tls):
- self.transport = tls
- self.transport.startTLS(context)
- self._capCache = None
- self.startedTLS = True
- return result
-
-
- def _getContextFactory(self):
- try:
- from twisted.internet import ssl
- except ImportError:
- return None
- else:
- context = ssl.ClientContextFactory()
- context.method = ssl.SSL.TLSv1_METHOD
- return context
-
-
- def login(self, username, password):
- """Log into the server.
-
- If APOP is available it will be used. Otherwise, if TLS is
- available an 'STLS' session will be started and plaintext
- login will proceed. Otherwise, if the instance attribute
- allowInsecureLogin is set to True, insecure plaintext login
- will proceed. Otherwise, InsecureAuthenticationDisallowed
- will be raised (asynchronously).
-
- @param username: The username with which to log in.
- @param password: The password with which to log in.
-
- @rtype: C{Deferred}
- @return: A deferred which fires when login has
- completed.
- """
- d = self.capabilities()
- d.addCallback(self._login, username, password)
- return d
-
-
- def _login(self, caps, username, password):
- if self.serverChallenge is not None:
- return self._apop(username, password, self.serverChallenge)
-
- tryTLS = 'STLS' in caps
-
- #If our transport supports switching to TLS, we might want to try to switch to TLS.
- tlsableTransport = interfaces.ITLSTransport(self.transport, None) is not None
-
- # If our transport is not already using TLS, we might want to try to switch to TLS.
- nontlsTransport = interfaces.ISSLTransport(self.transport, None) is None
-
- if not self.startedTLS and tryTLS and tlsableTransport and nontlsTransport:
- d = self.startTLS()
-
- d.addCallback(self._loginTLS, username, password)
- return d
-
- elif self.startedTLS or not nontlsTransport or self.allowInsecureLogin:
- return self._plaintext(username, password)
- else:
- return defer.fail(InsecureAuthenticationDisallowed())
-
-
- def _loginTLS(self, res, username, password):
- return self._plaintext(username, password)
-
- def _plaintext(self, username, password):
- # Internal helper. Send a username/password pair, returning a Deferred
- # that fires when both have succeeded or fails when the server rejects
- # either.
- return self.user(username).addCallback(lambda r: self.password(password))
-
- def _apop(self, username, password, challenge):
- # Internal helper. Computes and sends an APOP response. Returns
- # a Deferred that fires when the server responds to the response.
- digest = md5.new(challenge + password).hexdigest()
- return self.apop(username, digest)
-
- def apop(self, username, digest):
- """Perform APOP login.
-
- This should be used in special circumstances only, when it is
- known that the server supports APOP authentication, and APOP
- authentication is absolutely required. For the common case,
- use L{login} instead.
-
- @param username: The username with which to log in.
- @param digest: The challenge response to authenticate with.
- """
- return self.sendShort('APOP', username + ' ' + digest)
-
- def user(self, username):
- """Send the user command.
-
- This performs the first half of plaintext login. Unless this
- is absolutely required, use the L{login} method instead.
-
- @param username: The username with which to log in.
- """
- return self.sendShort('USER', username)
-
- def password(self, password):
- """Send the password command.
-
- This performs the second half of plaintext login. Unless this
- is absolutely required, use the L{login} method instead.
-
- @param password: The plaintext password with which to authenticate.
- """
- return self.sendShort('PASS', password)
-
- def delete(self, index):
- """Delete a message from the server.
-
- @type index: C{int}
- @param index: The index of the message to delete.
- This is 0-based.
-
- @rtype: C{Deferred}
- @return: A deferred which fires when the delete command
- is successful, or fails if the server returns an error.
- """
- return self.sendShort('DELE', str(index + 1))
-
- def _consumeOrSetItem(self, cmd, args, consumer, xform):
- # Internal helper. Send a long command. If no consumer is
- # provided, create a consumer that puts results into a list
- # and return a Deferred that fires with that list when it
- # is complete.
- if consumer is None:
- L = []
- consumer = _ListSetter(L).setitem
- return self.sendLong(cmd, args, consumer, xform).addCallback(lambda r: L)
- return self.sendLong(cmd, args, consumer, xform)
-
- def _consumeOrAppend(self, cmd, args, consumer, xform):
- # Internal helper. Send a long command. If no consumer is
- # provided, create a consumer that appends results to a list
- # and return a Deferred that fires with that list when it is
- # complete.
- if consumer is None:
- L = []
- consumer = L.append
- return self.sendLong(cmd, args, consumer, xform).addCallback(lambda r: L)
- return self.sendLong(cmd, args, consumer, xform)
-
- def capabilities(self, useCache=True):
- """Retrieve the capabilities supported by this server.
-
- Not all servers support this command. If the server does not
- support this, it is treated as though it returned a successful
- response listing no capabilities. At some future time, this may be
- changed to instead seek out information about a server's
- capabilities in some other fashion (only if it proves useful to do
- so, and only if there are servers still in use which do not support
- CAPA but which do support POP3 extensions that are useful).
-
- @type useCache: C{bool}
- @param useCache: If set, and if capabilities have been
- retrieved previously, just return the previously retrieved
- results.
-
- @return: A Deferred which fires with a C{dict} mapping C{str}
- to C{None} or C{list}s of C{str}. For example::
-
- C: CAPA
- S: +OK Capability list follows
- S: TOP
- S: USER
- S: SASL CRAM-MD5 KERBEROS_V4
- S: RESP-CODES
- S: LOGIN-DELAY 900
- S: PIPELINING
- S: EXPIRE 60
- S: UIDL
- S: IMPLEMENTATION Shlemazle-Plotz-v302
- S: .
-
- will be lead to a result of::
-
- | {'TOP': None,
- | 'USER': None,
- | 'SASL': ['CRAM-MD5', 'KERBEROS_V4'],
- | 'RESP-CODES': None,
- | 'LOGIN-DELAY': ['900'],
- | 'PIPELINING': None,
- | 'EXPIRE': ['60'],
- | 'UIDL': None,
- | 'IMPLEMENTATION': ['Shlemazle-Plotz-v302']}
- """
- if useCache and self._capCache is not None:
- return defer.succeed(self._capCache)
-
- cache = {}
- def consume(line):
- tmp = line.split()
- if len(tmp) == 1:
- cache[tmp[0]] = None
- elif len(tmp) > 1:
- cache[tmp[0]] = tmp[1:]
-
- def capaNotSupported(err):
- err.trap(ServerErrorResponse)
- return None
-
- def gotCapabilities(result):
- self._capCache = cache
- return cache
-
- d = self._consumeOrAppend('CAPA', None, consume, None)
- d.addErrback(capaNotSupported).addCallback(gotCapabilities)
- return d
-
-
- def noop(self):
- """Do nothing, with the help of the server.
-
- No operation is performed. The returned Deferred fires when
- the server responds.
- """
- return self.sendShort("NOOP", None)
-
-
- def reset(self):
- """Remove the deleted flag from any messages which have it.
-
- The returned Deferred fires when the server responds.
- """
- return self.sendShort("RSET", None)
-
-
- def retrieve(self, index, consumer=None, lines=None):
- """Retrieve a message from the server.
-
- If L{consumer} is not None, it will be called with
- each line of the message as it is received. Otherwise,
- the returned Deferred will be fired with a list of all
- the lines when the message has been completely received.
- """
- idx = str(index + 1)
- if lines is None:
- return self._consumeOrAppend('RETR', idx, consumer, _dotUnquoter)
-
- return self._consumeOrAppend('TOP', '%s %d' % (idx, lines), consumer, _dotUnquoter)
-
-
- def stat(self):
- """Get information about the size of this mailbox.
-
- The returned Deferred will be fired with a tuple containing
- the number or messages in the mailbox and the size (in bytes)
- of the mailbox.
- """
- return self.sendShort('STAT', None).addCallback(_statXform)
-
-
- def listSize(self, consumer=None):
- """Retrieve a list of the size of all messages on the server.
-
- If L{consumer} is not None, it will be called with two-tuples
- of message index number and message size as they are received.
- Otherwise, a Deferred which will fire with a list of B{only}
- message sizes will be returned. For messages which have been
- deleted, None will be used in place of the message size.
- """
- return self._consumeOrSetItem('LIST', None, consumer, _listXform)
-
-
- def listUID(self, consumer=None):
- """Retrieve a list of the UIDs of all messages on the server.
-
- If L{consumer} is not None, it will be called with two-tuples
- of message index number and message UID as they are received.
- Otherwise, a Deferred which will fire with of list of B{only}
- message UIDs will be returned. For messages which have been
- deleted, None will be used in place of the message UID.
- """
- return self._consumeOrSetItem('UIDL', None, consumer, _uidXform)
-
-
- def quit(self):
- """Disconnect from the server.
- """
- return self.sendShort('QUIT', None)
-
-__all__ = [
- # Exceptions
- 'InsecureAuthenticationDisallowed', 'LineTooLong', 'POP3ClientError',
- 'ServerErrorResponse', 'TLSError', 'TLSNotSupportedError',
-
- # Protocol classes
- 'POP3Client']
« no previous file with comments | « third_party/twisted_8_1/twisted/mail/pop3.py ('k') | third_party/twisted_8_1/twisted/mail/protocols.py » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698