def test_registerProducers(self):
"""
The proxy client registers itself as a producer of the proxy server and
vice versa.
"""
# create a ProxyServer instance
addr = address.IPv4Address('TCP', '127.0.0.1', 0)
server = portforward.ProxyFactory('127.0.0.1', 0).buildProtocol(addr)
# set the reactor for this test
reactor = proto_helpers.MemoryReactor()
server.reactor = reactor
# make the connection
serverTransport = proto_helpers.StringTransport()
server.makeConnection(serverTransport)
# check that the ProxyClientFactory is connecting to the backend
self.assertEqual(len(reactor.tcpClients), 1)
# get the factory instance and check it's the one we expect
host, port, clientFactory, timeout, _ = reactor.tcpClients[0]
self.assertIsInstance(clientFactory, portforward.ProxyClientFactory)
# Connect it
client = clientFactory.buildProtocol(addr)
clientTransport = proto_helpers.StringTransport()
client.makeConnection(clientTransport)
# check that the producers are registered
self.assertIs(clientTransport.producer, serverTransport)
self.assertIs(serverTransport.producer, clientTransport)
# check the streaming attribute in both transports
self.assertTrue(clientTransport.streaming)
self.assertTrue(serverTransport.streaming)
def test_pendingEmptiedInPlaceOnError(self):
"""
When the TCP connection attempt fails, the
L{client.Resolver.pending} list is emptied in place. It is not
replaced with a new empty list.
"""
reactor = proto_helpers.MemoryReactor()
resolver = client.Resolver(servers=[("192.0.2.100", 53)], reactor=reactor)
d = resolver.queryTCP(dns.Query("example.com"))
host, port, factory, timeout, bindAddress = reactor.tcpClients[0]
prePending = resolver.pending
self.assertEqual(len(prePending), 1)
class SentinelException(Exception):
pass
factory.clientConnectionFailed(
reactor.connectors[0], failure.Failure(SentinelException())
)
self.failureResultOf(d, SentinelException)
self.assertIs(resolver.pending, prePending)
self.assertEqual(len(prePending), 0)
def test_streamAcceptEstablished(self):
mreactor = proto_helpers.MemoryReactor()
session = Mock()
listeningPort = Mock()
fac, proto = self.makeProto(Mock(), session, listeningPort)
# Shortcut to end of SAM stream accept protocol
proto.receiver.currentRule = 'State_accept'
proto._parser._setupInterp()
proto.dataReceived('STREAM STATUS RESULT=OK\n')
session.addStream.assert_called_with(proto.receiver)
listeningPort.addAccept.assert_called_with(proto.receiver)
def test_streamForwardEstablished(self):
mreactor = proto_helpers.MemoryReactor()
session = Mock()
fac, proto = self.makeProto(session, '')
# Shortcut to end of SAM stream forward protocol
proto.receiver.currentRule = 'State_forward'
proto._parser._setupInterp()
proto.dataReceived('STREAM STATUS RESULT=OK\n')
session.addStream.assert_called_with(proto.receiver)
streamProto = self.successResultOf(fac.deferred)
self.assertEqual(proto.receiver, streamProto)
def TODO_test_noProtocolFromWrappedFactory(self):
wrappedFac = FakeFactory(returnNoProtocol=True)
mreactor = proto_helpers.MemoryReactor()
fac, proto = self.makeProto(mreactor, wrappedFac, None, '')
fac.tunnelNick = 'spam'
# Shortcut to end of BOB protocol
proto.receiver.currentRule = 'State_start'
proto._parser._setupInterp()
proto.dataReceived('OK HTTP 418\n')
self.assert_(self.aborted) # TODO: Check the Deferred chain
return self.assertFailure(fac.deferred, defer.CancelledError)
def test_streamConnectionEstablished(self):
mreactor = proto_helpers.MemoryReactor()
wrappedFactory = FakeFactory()
session = Mock()
fac, proto = self.makeProto(wrappedFactory, session, 'spam.i2p', 'foo')
# Shortcut to end of SAM stream connect protocol
proto.receiver.currentRule = 'State_connect'
proto._parser._setupInterp()
proto.dataReceived('STREAM STATUS RESULT=OK\n')
session.addStream.assert_called_with(proto.receiver)
streamProto = self.successResultOf(fac.deferred)
self.assertEqual(proto.receiver.wrappedProto, streamProto)
def test_destGenerated(self):
tmp = '/tmp/TestDestGenerateFactory.privKey'
mreactor = proto_helpers.MemoryReactor()
fac, proto = self.makeProto(tmp)
# Shortcut to end of SAM dest generate protocol
proto.receiver.currentRule = 'State_dest'
proto._parser._setupInterp()
proto.dataReceived('DEST REPLY PUB=%s PRIV=%s\n' %
(TEST_B64, 'TEST_PRIV'))
s = self.successResultOf(fac.deferred)
self.assertEqual(I2PAddress(TEST_B64), s)
os.remove(tmp)
def test_streamAcceptIncoming(self):
mreactor = proto_helpers.MemoryReactor()
wrappedFactory = FakeFactory()
session = Mock()
listeningPort = Mock()
fac, proto = self.makeProto(wrappedFactory, session, listeningPort)
# Shortcut to end of SAM stream accept protocol
proto.receiver.currentRule = 'State_readData'
proto._parser._setupInterp()
proto.dataReceived('%s FROM_PORT=34444 TO_PORT=0\n' % TEST_B64)
listeningPort.removeAccept.assert_called_with(proto.receiver)
self.assertEqual(wrappedFactory.proto, proto.receiver.wrappedProto)
def test_sessionCreated(self):
mreactor = proto_helpers.MemoryReactor()
fac, proto = self.makeProto('foo')
fac.samVersion = '3.1'
# Shortcut to end of SAM session create protocol
proto.receiver.currentRule = 'State_naming'
proto._parser._setupInterp()
proto.dataReceived('NAMING REPLY RESULT=OK NAME=ME VALUE=%s\n' %
TEST_B64)
s = self.successResultOf(fac.deferred)
self.assertEqual(
('3.1', 'STREAM', 'foo', proto.receiver, TEST_B64, None), s)
def test_endpoint_launch_tor(self, private_tor, global_tor, system_tor):
"""
we just want to confirm that calling listen results in the
spawning of a Tor process; the parsing/setup from string are
checked elsewhere.
"""
reactor = proto_helpers.MemoryReactor()
ep = serverFromString(reactor, 'onion:8888')
r = yield ep.listen(NoOpProtocolFactory())
self.assertEqual(global_tor.call_count, 1)
self.assertEqual(private_tor.call_count, 0)
self.assertEqual(system_tor.call_count, 0)
def test_destGenerated_privKeySaved(self):
tmp = '/tmp/TestDestGenerateFactory.privKey'
mreactor = proto_helpers.MemoryReactor()
fac, proto = self.makeProto(tmp)
# Shortcut to end of SAM dest generate protocol
proto.receiver.currentRule = 'State_dest'
proto._parser._setupInterp()
proto.dataReceived('DEST REPLY PUB=%s PRIV=%s\n' %
(TEST_B64, 'TEST_PRIV'))
f = open(tmp, 'r')
privKey = f.read()
f.close()
self.assertEqual('TEST_PRIV', privKey)
os.remove(tmp)
def test_endpoint_connect_tor(self, private_tor, global_tor, system_tor):
"""
similar to above test, we're confirming that an
endpoint-string with 'controlPort=xxxx' in it calls the API
that will connect to a running Tor.
"""
reactor = proto_helpers.MemoryReactor()
ep = serverFromString(reactor,
'onion:8888:controlPort=9055:localPort=1234')
r = yield ep.listen(NoOpProtocolFactory())
self.assertEqual(global_tor.call_count, 0)
self.assertEqual(private_tor.call_count, 0)
self.assertEqual(system_tor.call_count, 1)
def test_destGenerated_keyfileExists(self):
tmp = '/tmp/TestDestGenerateFactory.privKey'
f = open(tmp, 'w')
f.write('foo')
f.close()
mreactor = proto_helpers.MemoryReactor()
fac, proto = self.makeProto(tmp)
# Shortcut to end of SAM dest generate protocol
proto.receiver.currentRule = 'State_dest'
proto._parser._setupInterp()
proto.dataReceived('DEST REPLY PUB=%s PRIV=%s\n' %
(TEST_B64, 'TEST_PRIV'))
self.assertIsInstance(
self.failureResultOf(fac.deferred).value, ValueError)
os.remove(tmp)
def test_reentrantTCPQueryErrbackOnConnectionFailure(self):
"""
An errback on the deferred returned by
L{client.Resolver.queryTCP} may trigger another TCP query.
"""
reactor = proto_helpers.MemoryReactor()
resolver = client.Resolver(
servers=[('127.0.0.1', 10053)],
reactor=reactor)
q = dns.Query('example.com')
# First query sent
d = resolver.queryTCP(q)
# Repeat the query when the first query fails
def reissue(e):
e.trap(ConnectionRefusedError)
return resolver.queryTCP(q)
d.addErrback(reissue)
self.assertEqual(len(reactor.tcpClients), 1)
self.assertEqual(len(reactor.connectors), 1)
host, port, factory, timeout, bindAddress = reactor.tcpClients[0]
# First query fails
f1 = failure.Failure(ConnectionRefusedError())
factory.clientConnectionFailed(
reactor.connectors[0],
f1)
# A second TCP connection is immediately attempted
self.assertEqual(len(reactor.tcpClients), 2)
self.assertEqual(len(reactor.connectors), 2)
# No result expected until the second chained query returns
self.assertNoResult(d)
# Second query fails
f2 = failure.Failure(ConnectionRefusedError())
factory.clientConnectionFailed(
reactor.connectors[1],
f2)
# Original deferred now fires with the second failure
f = self.failureResultOf(d, ConnectionRefusedError)
self.assertIdentical(f, f2)
def test_sessionCreatedWithKeyfile(self):
tmp = '/tmp/TestSessionCreateFactory.privKey'
mreactor = proto_helpers.MemoryReactor()
fac, proto = self.makeProto('foo', keyfile=tmp)
fac.samVersion = '3.1'
fac.privKey = 'bar'
fac._writeKeypair = True
# Shortcut to end of SAM session create protocol
proto.receiver.currentRule = 'State_naming'
proto._parser._setupInterp()
proto.dataReceived('NAMING REPLY RESULT=OK NAME=ME VALUE=%s\n' %
TEST_B64)
f = open(tmp, 'r')
privKey = f.read()
f.close()
self.assertEqual('bar', privKey)
# Cleanup
os.remove(tmp)
def test_singleTCPQueryErrbackOnConnectionFailure(self):
"""
The deferred returned by L{client.Resolver.queryTCP} will
errback when the TCP connection attempt fails. The reason for
the connection failure is passed as the argument to errback.
"""
reactor = proto_helpers.MemoryReactor()
resolver = client.Resolver(servers=[("192.0.2.100", 53)], reactor=reactor)
d = resolver.queryTCP(dns.Query("example.com"))
host, port, factory, timeout, bindAddress = reactor.tcpClients[0]
class SentinelException(Exception):
pass
factory.clientConnectionFailed(
reactor.connectors[0], failure.Failure(SentinelException())
)
self.failureResultOf(d, SentinelException)
def test_multipleTCPQueryErrbackOnConnectionFailure(self):
"""
All pending L{resolver.queryTCP} C{deferred}s will C{errback}
with the same C{Failure} if the connection attempt fails.
"""
reactor = proto_helpers.MemoryReactor()
resolver = client.Resolver(servers=[("192.0.2.100", 53)], reactor=reactor)
d1 = resolver.queryTCP(dns.Query("example.com"))
d2 = resolver.queryTCP(dns.Query("example.net"))
host, port, factory, timeout, bindAddress = reactor.tcpClients[0]
class SentinelException(Exception):
pass
factory.clientConnectionFailed(
reactor.connectors[0], failure.Failure(SentinelException())
)
f1 = self.failureResultOf(d1, SentinelException)
f2 = self.failureResultOf(d2, SentinelException)
self.assertIs(f1, f2)
def test_reconnection(self):
clock = task.Clock()
self.factory.clock = clock
self.factory.maxRetries = 3
fakeReactor = proto_helpers.MemoryReactor()
self.assertEquals(0, len(fakeReactor.tcpClients))
connector = fakeReactor.connectTCP('fakehost', 1234, self.factory)
self.assertEquals(1, len(fakeReactor.tcpClients))
for i in xrange(self.factory.maxRetries):
self.factory.clientConnectionFailed(connector, "Attempt %d" % i)
self.assertEquals(1, len(clock.getDelayedCalls()))
clock.advance(self.factory.delay)
self.assertEquals(0, len(clock.getDelayedCalls()))
self.assertEquals(i + 1, connector.connectionAttempts)
self.factory.clientConnectionFailed(connector, "Attempt %d" % i)
self.assertEquals(0, len(clock.getDelayedCalls()))
clock.advance(self.factory.delay)
self.assertEquals(self.factory.retries - 1,
connector.connectionAttempts)
def setUp(self):
self.reactor = proto_helpers.MemoryReactor()
def setUp(self):
self.reactor = proto_helpers.MemoryReactor()
self.env = _createEnv(self.reactor)
self.clock = task.Clock()
self.checker = TestChecker(5)
self.scan = scanner.Scan(self.clock, '127.0.0.1')
def test_onion_parse_unix_socket(self):
r = proto_helpers.MemoryReactor()
serverFromString(r, "onion:80:controlPort=/tmp/foo")
def test_samConnected(self):
mreactor = proto_helpers.MemoryReactor()
fac, proto = self.makeProto()
proto.dataReceived('HELLO REPLY RESULT=OK VERSION=3.1\n')
s = self.successResultOf(fac.deferred)
self.assertEqual(True, s)
