|  |  | 
gdata.tlslite.integration.AsyncStateMachine.AsyncStateMachine
TLSTwistedProtocolWrapper(twisted.protocols.policies.ProtocolWrapper, gdata.tlslite.integration.AsyncStateMachine.AsyncStateMachine)
twisted.protocols.policies.ProtocolWrapper(twisted.internet.protocol.Protocol)
TLSTwistedProtocolWrapper(twisted.protocols.policies.ProtocolWrapper, gdata.tlslite.integration.AsyncStateMachine.AsyncStateMachine)
 
 
| class TLSTwistedProtocolWrapper(twisted.protocols.policies.ProtocolWrapper, gdata.tlslite.integration.AsyncStateMachine.AsyncStateMachine)
 |  |  | This class can wrap Twisted protocols to add TLS support. 
 Below is a complete example of using TLS Lite with a Twisted echo
 server.
 
 There are two server implementations below.  Echo is the original
 protocol, which is oblivious to TLS.  Echo1 subclasses Echo and
 negotiates TLS when the client connects.  Echo2 subclasses Echo and
 negotiates TLS when the client sends "STARTTLS"::
 
 from twisted.internet.protocol import Protocol, Factory
 from twisted.internet import reactor
 from twisted.protocols.policies import WrappingFactory
 from twisted.protocols.basic import LineReceiver
 from twisted.python import log
 from twisted.python.failure import Failure
 import sys
 from tlslite.api import *
 
 s = open("./serverX509Cert.pem").read()
 x509 = X509()
 x509.parse(s)
 certChain = X509CertChain([x509])
 
 s = open("./serverX509Key.pem").read()
 privateKey = parsePEMKey(s, private=True)
 
 verifierDB = VerifierDB("verifierDB")
 verifierDB.open()
 
 class Echo(LineReceiver):
 def connectionMade(self):
 self.transport.write("Welcome to the echo server!\r\n")
 
 def lineReceived(self, line):
 self.transport.write(line + "\r\n")
 
 class Echo1(Echo):
 def connectionMade(self):
 if not self.transport.tlsStarted:
 self.transport.setServerHandshakeOp(certChain=certChain,
 privateKey=privateKey,
 verifierDB=verifierDB)
 else:
 Echo.connectionMade(self)
 
 def connectionLost(self, reason):
 pass #Handle any TLS exceptions here
 
 class Echo2(Echo):
 def lineReceived(self, data):
 if data == "STARTTLS":
 self.transport.setServerHandshakeOp(certChain=certChain,
 privateKey=privateKey,
 verifierDB=verifierDB)
 else:
 Echo.lineReceived(self, data)
 
 def connectionLost(self, reason):
 pass #Handle any TLS exceptions here
 
 factory = Factory()
 factory.protocol = Echo1
 #factory.protocol = Echo2
 
 wrappingFactory = WrappingFactory(factory)
 wrappingFactory.protocol = TLSTwistedProtocolWrapper
 
 log.startLogging(sys.stdout)
 reactor.listenTCP(1079, wrappingFactory)
 reactor.run()
 
 This class works as follows:
 
 Data comes in and is given to the AsyncStateMachine for handling.
 AsyncStateMachine will forward events to this class, and we'll
 pass them on to the ProtocolHandler, which will proxy them to the
 wrapped protocol.  The wrapped protocol may then call back into
 this class, and these calls will be proxied into the
 AsyncStateMachine.
 
 The call graph looks like this:
 - self.dataReceived
 - AsyncStateMachine.inReadEvent
 - out(Connect|Close|Read)Event
 - ProtocolWrapper.(connectionMade|loseConnection|dataReceived)
 - self.(loseConnection|write|writeSequence)
 - AsyncStateMachine.(setCloseOp|setWriteOp)
 
 |  |  | Method resolution order:TLSTwistedProtocolWrappertwisted.protocols.policies.ProtocolWrappertwisted.internet.protocol.Protocoltwisted.internet.protocol.BaseProtocolgdata.tlslite.integration.AsyncStateMachine.AsyncStateMachine
 Methods defined here:
 
 __init__(self, factory, wrappedProtocol)
 connectionLost(self, reason)
 connectionMade(self)
 dataReceived(self, data)
 loseConnection(self)
 outCloseEvent(self)
 outConnectEvent(self)
 outReadEvent(self, data)
 setServerHandshakeOp(self, **args)
 write(self, data)
 writeSequence(self, seq)
 Methods inherited from twisted.protocols.policies.ProtocolWrapper:
 
 __getattr__(self, name)
 getHost(self)
 getPeer(self)
 logPrefix(self)Use a customized log prefix mentioning both the wrapped protocol andthe current one.
 makeConnection(self, transport)When a connection is made, register this wrapper with its factory,save the real transport, and connect the wrapped protocol to this
 L{ProtocolWrapper} to intercept any transport calls it makes.
 registerProducer(self, producer, streaming)
 stopConsuming(self)
 unregisterProducer(self)
 Data and other attributes inherited from twisted.protocols.policies.ProtocolWrapper:
 
 disconnecting = 0
 Methods inherited from twisted.internet.protocol.Protocol:
 
 __provides__Special descriptor for class __provides__
 The descriptor caches the implementedBy info, so that
 we can get declarations for objects without instance-specific
 interfaces a bit quicker.
 
 For example:
 
 >>> from zope.interface import Interface
 >>> class IFooFactory(Interface):
 ...     pass
 >>> class IFoo(Interface):
 ...     pass
 >>> class C(object):
 ...     implements(IFoo)
 ...     classProvides(IFooFactory)
 >>> [i.getName() for i in C.__provides__]
 ['IFooFactory']
 
 >>> [i.getName() for i in C().__provides__]
 ['IFoo']
 Data and other attributes inherited from twisted.internet.protocol.Protocol:
 
 __implemented__ = <implementedBy twisted.internet.protocol.Protocol>
 Methods inherited from twisted.internet.protocol.BaseProtocol:
 __providedBy__ = <zope.interface.declarations.Declaration object>
 Data and other attributes inherited from twisted.internet.protocol.BaseProtocol:
 
 connected = 0
 transport = None
 Methods inherited from gdata.tlslite.integration.AsyncStateMachine.AsyncStateMachine:
 
 inReadEvent(self)Tell the state machine it can read from the socket.
 inWriteEvent(self)Tell the state machine it can write to the socket.
 outWriteEvent(self)Called when a write operation completes.
 May be overridden in subclass.
 setCloseOp(self)Start a close operation.
 setHandshakeOp(self, handshaker)Start a handshake operation.
 @type handshaker: generator
 @param handshaker: A generator created by using one of the
 asynchronous handshake functions (i.e. handshakeServerAsync, or
 handshakeClientxxx(..., async=True).
 setWriteOp(self, writeBuffer)Start a write operation.
 @type writeBuffer: str
 @param writeBuffer: The string to transmit.
 wantsReadEvent(self)If the state machine wants to read.
 If an operation is active, this returns whether or not the
 operation wants to read from the socket.  If an operation is
 not active, this returns None.
 
 @rtype: bool or None
 @return: If the state machine wants to read.
 wantsWriteEvent(self)If the state machine wants to write.
 If an operation is active, this returns whether or not the
 operation wants to write to the socket.  If an operation is
 not active, this returns None.
 
 @rtype: bool or None
 @return: If the state machine wants to write.
 |  |