def parseStreamServer(self, reactor, public_port, localPort=None,
controlPort=None, hiddenServiceDir=None):
''':api:`twisted.internet.interfaces.IStreamServerEndpointStringParser`'''
public_port = int(public_port)
if localPort is not None:
localPort = int(localPort)
hsd = hiddenServiceDir
if hsd:
orig = hsd
hsd = os.path.expanduser(hsd)
hsd = os.path.realpath(hsd)
if orig != hsd:
log.msg('Using "%s" for hsd' % hsd)
if controlPort:
try:
ep = clientFromString(reactor, "tcp:host=127.0.0.1:port=%d" % int(controlPort))
except ValueError:
ep = clientFromString(reactor, "unix:path=%s" % controlPort)
return TCPHiddenServiceEndpoint.system_tor(reactor, ep,
public_port,
hidden_service_dir=hsd,
local_port=localPort)
return TCPHiddenServiceEndpoint.global_tor(reactor, public_port,
hidden_service_dir=hsd,
local_port=localPort,
control_port=controlPort)
def run_command(config):
c = dispatch_table[config.subCommand]()
tub = Tub()
try:
from twisted.internet import reactor
from twisted.internet.endpoints import clientFromString
from foolscap.connections import tor
CONTROL = os.environ.get("FOOLSCAP_TOR_CONTROL_PORT", "")
SOCKS = os.environ.get("FOOLSCAP_TOR_SOCKS_PORT", "")
if CONTROL:
h = tor.control_endpoint(clientFromString(reactor, CONTROL))
tub.addConnectionHintHandler("tor", h)
elif SOCKS:
h = tor.socks_endpoint(clientFromString(reactor, SOCKS))
tub.addConnectionHintHandler("tor", h)
#else:
# h = tor.default_socks()
# tub.addConnectionHintHandler("tor", h)
except ImportError:
pass
d = defer.succeed(None)
d.addCallback(lambda _ign: tub.startService())
d.addCallback(lambda _ign: tub.getReference(config.furl))
d.addCallback(c.run, config.subOptions) # might provide tub here
d.addBoth(lambda res: tub.stopService().addCallback(lambda _ign: res))
return d
def get(host, path):
f = protocol.ClientFactory()
f.protocol = HTTPGETProtocol
f.path = path
f.host = host
f.deferred = defer.Deferred()
strport = "tcp:%s:80" % host
endpoints.clientFromString(reactor, strport).connect(f)
return f.deferred
def start():
""" Client Entrypoint """
endpoints.clientFromString(reactor, "tcp:localhost:1234").connect(PrintClientFactory())
# gui = GameWindow()
# gui_loop = task.LoopingCall(gui.update)
# gui_loop.start(1.0)
reactor.run()
async def _startup(reactor):
if cfg.connect.startswith('tcp:') or cfg.connect.startswith('unix:'):
ep = clientFromString(reactor, cfg.connect)
else:
if ':' in cfg.connect:
ep = clientFromString(reactor, 'tcp:{}'.format(cfg.connect))
else:
ep = clientFromString(reactor, 'tcp:localhost:{}'.format(cfg.connect))
tor = await txtorcon.connect(reactor, ep)
if cfg.debug_protocol:
click.echo("Low-level protocol debugging: ", nl=False)
click.echo(click.style("data we write to Tor, ", fg='blue'), nl=False)
click.echo(click.style("data from Tor", fg='yellow') + ".")
def write_wrapper(data):
tail = data
while len(tail):
head, tail = tail.split('\r\n', 1)
click.echo(">>> " + click.style(head, fg='blue'), nl=False)
click.echo()
return orig_write(data)
orig_write = tor.protocol.transport.write
tor.protocol.transport.write = write_wrapper
def read_wrapper(data):
tail = data
while '\r\n' in tail:
head, tail = tail.split('\r\n', 1)
if not read_wrapper.write_prefix:
click.echo(click.style(head, fg='yellow'))
read_wrapper.write_prefix = True
else:
click.echo("<<< " + click.style(head, fg='yellow'))
if len(tail):
click.echo("<<< " + click.style(tail, fg='yellow'), nl=False)
read_wrapper.write_prefix = False
else:
click.echo()
return orig_read(data)
read_wrapper.write_prefix = True
orig_read = tor.protocol.dataReceived
tor.protocol.dataReceived = read_wrapper
if cfg.info:
info = await tor.protocol.get_info('version', 'status/version/current', 'dormant')
click.echo(
'Connected to a Tor version "{version}" (status: '
'{status/version/current}).\n'.format(**info)
)
await cmd(reactor, cfg, tor, *args, **kwargs)
def test_parse_client_basic(self):
from twisted.plugins import autobahn_endpoints
self.assertTrue(hasattr(autobahn_endpoints, "AutobahnClientParser"))
from twisted.internet.endpoints import clientFromString, quoteStringArgument
from twisted.internet import reactor
ep_string = "autobahn:{0}:url={1}".format(
quoteStringArgument("tcp:localhost:9000"), quoteStringArgument("ws://localhost:9000")
)
# we're just testing that this doesn't fail entirely
clientFromString(reactor, ep_string)
def connect(hostname, worker=None, on_connect=None):
"""
Connect to server using GrideaProtocol, automatically retry if it is
not yet running.
:param hostname: `hostname:port` to connect to
:param worker: optional gridea.GrideaWorker() to make this process a worker
:param on_connect: optional callback after connection
"""
class ClientFactory(ReconnectingClientFactory):
def buildProtocol(self, addr):
return GrideaProtocol(worker, on_connect)
clientFromString(reactor, 'tcp:' + hostname).connect(ClientFactory())
def _build_endpoint(cls, endpoint_string=None, encrypted=True, timeout=5, host=None, reactor=None):
if not reactor:
from twisted.internet import reactor
host = host or cls.host
if endpoint_string:
endpoint = clientFromString(reactor, endpoint_string)
else:
if encrypted:
port = 443
proto = 'ssl'
else:
port = 80
proto = 'tcp'
endpoint = clientFromString(reactor, '{0}:host={1}:port={2}:timeout={3}'.format(proto, host, port, timeout))
return endpoint
def generateDestination(reactor, keyfile, api=None, apiEndpoint=None):
"""Generate a new I2P Destination.
The function returns a :class:`twisted.internet.defer.Deferred`; register
callbacks to receive the return value or errors.
Args:
reactor: The API endpoint will be constructed with this reactor.
keyfile (str): Path to a local file where the keypair for the new
Destination should be stored.
api (str): The API to use.
apiEndpoint (str): An endpoint string that will connect to the API.
Alternatively, the caller can directly provide an
:class:`twisted.internet.interfaces.IStreamClientEndpoint`, and the
``reactor`` will be ignored.
Returns:
txi2p.I2PAddress: The new Destination. Once this is received via the
Deferred callback, the ``keyfile`` will have been written.
Raises:
ValueError: if the API doesn't support this method.
ValueError: if the ``keyfile`` already exists.
IOError: if the ``keyfile`` write fails.
"""
api, apiEndpoint = getApi(api, apiEndpoint, _apiGenerators)
if isinstance(apiEndpoint, str):
apiEndpoint = clientFromString(reactor, apiEndpoint)
return _apiGenerators[api](keyfile, apiEndpoint)
def test_basic(self):
ep = clientFromString(reactor, self.transit)
a1 = yield connectProtocol(ep, Accumulator())
a2 = yield connectProtocol(ep, Accumulator())
token1 = b"\x00"*32
a1.transport.write(b"please relay " + hexlify(token1) + b"\n")
a2.transport.write(b"please relay " + hexlify(token1) + b"\n")
# a correct handshake yields an ack, after which we can send
exp = b"ok\n"
yield a1.waitForBytes(len(exp))
self.assertEqual(a1.data, exp)
s1 = b"data1"
a1.transport.write(s1)
exp = b"ok\n"
yield a2.waitForBytes(len(exp))
self.assertEqual(a2.data, exp)
# all data they sent after the handshake should be given to us
exp = b"ok\n"+s1
yield a2.waitForBytes(len(exp))
self.assertEqual(a2.data, exp)
a1.transport.loseConnection()
a2.transport.loseConnection()
def connect(self, terminal=None, on_error=None):
connection_string = "tcp:host={host}:port={port}".format(
host=self.options["host"],
port=self.options["port"]
)
log.msg("Connecting with connection string %s" % connection_string)
# TODO: add port forwarding here
ssh_connection = SSHConnection(self, terminal)
# TODO: verify host keys
vhk = lambda *a: defer.succeed(1)
# Build a basic auth client. There's a Twisted implementation
# for this, but we need something simpler that does not access
# keys that are stored on the disk
uao = AuthClient(self.options, ssh_connection)
d = defer.Deferred()
factory = direct.SSHClientFactory(d, self.options, vhk, uao)
if on_error:
d.addErrback(on_error)
endpoint = endpoints.clientFromString(reactor, connection_string)
wp = None
try:
wp = yield endpoint.connect(factory)
except Exception:
terminal.leave()
defer.returnValue(wp)
def main(reactor):
will_send_message = len(sys.argv) > 1
ep = endpoints.clientFromString(reactor, "tcp:localhost:4002")
f = WebSocketClientFactory("ws://127.0.0.1:4002/")
f.reactor = reactor
f.protocol = RelayEchoClient
f.token = "a" * 64
f.side = "0" * 16 if will_send_message else "1" * 16
f.done = Deferred()
f.ready = Deferred()
proto = yield ep.connect(f)
print("proto", proto)
yield f.ready
print("ready")
if will_send_message:
for _ in range(5):
print("sending message")
proto.sendMessage(b"it's a message", True)
yield deferLater(reactor, 0.2)
yield proto.sendClose()
print("closing")
yield f.done
print("relayed {} bytes:".format(len(proto._received)))
print(proto._received.decode("utf8"))
def makeService(config):
s = MultiService()
# ZipkinTracer(
# scribe_client,
# category=None,
# end_annotations=None,
# max_traces=50,
# max_idle_time=10,
# _reactor=None)
push_tracer(
ZipkinTracer(
ScribeClient(clientFromString(reactor, config['scribe'])), 'zipkin', None, 10, 10, None))
root = RootResource()
# if config['rproxy']:
# root = RProxyWrapper(root)
site = server.Site(root)
site.displayTracebacks = False
api_service = strports.service(config['port'], site)
api_service.setServiceParent(s)
return s
def test_parser_basic(self):
ep = clientFromString(None, 'tor:host=timaq4ygg2iegci7.onion:port=80:socksPort=9050')
self.assertEqual(ep.host, 'timaq4ygg2iegci7.onion')
self.assertEqual(ep.port, 80)
# XXX what's "the Twisted way" to get the port out here?
self.assertEqual(ep._socks_endpoint._port, 9050)
def test_system_tor(self, ftb):
def boom():
# why does the new_callable thing need a callable that
# returns a callable? Feels like I must be doing something
# wrong somewhere...
def bam(*args, **kw):
self.config.bootstrap()
return defer.succeed(Tor(Mock(), self.config))
return bam
with patch('txtorcon.endpoints.launch_tor') as launch_mock:
with patch('txtorcon.controller.connect', new_callable=boom):
client = clientFromString(
self.reactor,
"tcp:host=localhost:port=9050"
)
ep = yield TCPHiddenServiceEndpoint.system_tor(self.reactor,
client, 80)
port = yield ep.listen(NoOpProtocolFactory())
toa = port.getHost()
self.assertTrue(hasattr(toa, 'onion_uri'))
self.assertTrue(hasattr(toa, 'onion_port'))
port.startListening()
str(port)
port.tor_config
# system_tor should be connecting to a running one,
# *not* launching a new one.
self.assertFalse(launch_mock.called)
def test_system_tor(self):
from test_torconfig import FakeControlProtocol
def boom(*args):
# why does the new_callable thing need a callable that
# returns a callable? Feels like I must be doing something
# wrong somewhere...
def bam(*args, **kw):
return self.protocol
return bam
with patch('txtorcon.endpoints.launch_tor') as m:
with patch('txtorcon.endpoints.build_tor_connection',
new_callable=boom) as btc:
client = clientFromString(self.reactor,
"tcp:host=localhost:port=9050")
ep = yield TCPHiddenServiceEndpoint.system_tor(
self.reactor, client, 80)
port = yield ep.listen(NoOpProtocolFactory())
toa = port.getHost()
self.assertTrue(hasattr(toa, 'onion_uri'))
self.assertTrue(hasattr(toa, 'onion_port'))
port.startListening()
str(port)
port.tor_config
m.assert_called()
def connectSSH(self, strport, sshConnection=None):
if sshConnection is None:
sshConnection = SSHConnection(self, self.options)
#vhk = default.verifyHostKey
vhk = lambda *a: defer.succeed(1)
uao = default.SSHUserAuthClient(self.options['user'], self.options,
sshConnection)
d = defer.Deferred()
factory = direct.SSHClientFactory(d, self.options, vhk, uao)
endpoint = endpoints.clientFromString(reactor, strport)
try:
wp = yield endpoint.connect(factory)
except Exception:
def _stop():
try:
reactor.stop()
except:
pass
reactor.callLater(0.1, _stop)
raise
defer.returnValue(wp)
def _connect(self, reactor, update_status):
# create a new Tor
config = self.config = txtorcon.TorConfig()
if self._data_directory:
# The default is for launch_tor to create a tempdir itself, and
# delete it when done. We only need to set a DataDirectory if we
# want it to be persistent. This saves some startup time, because
# we cache the descriptors from last time. On one of my hosts,
# this reduces connect from 20s to 15s.
if not os.path.exists(self._data_directory):
# tor will mkdir this, but txtorcon wants to chdir to it
# before spawning the tor process, so (for now) we need to
# mkdir it ourselves. TODO: txtorcon should take
# responsibility for this.
os.mkdir(self._data_directory)
config.DataDirectory = self._data_directory
#config.ControlPort = allocate_tcp_port() # defaults to 9052
config.SocksPort = allocate_tcp_port()
socks_desc = "tcp:127.0.0.1:%d" % config.SocksPort
self._socks_desc = socks_desc # stash for tests
socks_endpoint = clientFromString(reactor, socks_desc)
with add_context(update_status, "launching Tor"):
tpp = yield txtorcon.launch_tor(config,
reactor,
tor_binary=self._tor_binary)
#print "launched"
# gives a TorProcessProtocol with .tor_protocol
self._tor_protocol = tpp.tor_protocol
returnValue(socks_endpoint)
def main(reactor, *descriptions):
log = Logger()
globalLogBeginner.beginLoggingTo([textFileLogObserver(sys.stdout)])
endpointObjects = [
endpoints.clientFromString(reactor, description)
for description in descriptions
]
hostPorts = [(endpoint._host, endpoint._port)
for endpoint in endpointObjects]
pool = threadpool.ThreadPool(minthreads=1, maxthreads=1, name="persiter")
persister = Persists(reactor, pool)
reactor.addSystemEventTrigger("before", "shutdown", persister.stop)
persister.start("log.sqlite", hostPorts)
analyzer = AnalyzesText(persister)
factory = EncodingCollectionFactory(reactor, random.SystemRandom(),
analyzer)
for (host, port), endpoint in zip(hostPorts, endpointObjects):
try:
protocol = yield endpoint.connect(factory)
except Exception:
log.failure("Could not connect to {host}:{port}",
host=host,
port=port)
raise
protocol.addr = (host, port)
defer.returnValue(defer.Deferred())
def test_unix_connect(self):
"""Demonstrate that the service connects to a Unix domain socket."""
self.assertEqual(len(self.reactor.unixClients), 0)
ep = clientFromString(self.reactor, "unix:/dev/null")
service = makeSubscriberService(ep, "ivo://foo/bar", [], [], [])
service.startService()
self.assertEqual(len(self.reactor.unixClients), 1)
def test_tcp_connect(self):
"""Demonstrate that the service connects to a TCP socket."""
self.assertEqual(len(self.reactor.tcpClients), 0)
ep = clientFromString(self.reactor, "tcp:foo:8099")
service = makeSubscriberService(ep, "ivo://foo/bar", [], [], [])
service.startService()
self.assertEqual(len(self.reactor.tcpClients), 1)
def do_connect(self, domain: str, port: int):
"""
If using CONNECT, the client is now in the established state.
:param domain: 服务端地址
:param port: 服务端端口
:return: defer
"""
self.log.info('do connect command')
# Don't read anything from the connecting client until we have somewhere to send it to.
self.transport.pauseProducing()
point = clientFromString(self.factory.reactor, f"tcp:host={domain}:port={port}")
d = connectProtocol(point, ProxyClient(self))
def success(ignored):
self.log.info("connected to {domain}, {port}", domain=domain, port=port)
# We're connected, everybody can read to their hearts content.
self.transport.resumeProducing()
self.make_reply(constants.SOCKS5_GRANTED, address=self.client.host_address)
self.set_state(self.STATE_ESTABLISHED)
def error(failure):
raise errors.HostUnreachable()
d.addCallbacks(success, error)
return d
def test_tls_socks_with_endpoint(self, ep_mock):
"""
Same as above, except we provide an explicit endpoint
"""
if not _HAVE_TLS:
print ("no TLS support")
return
class FakeWrappedProto(object):
wrappedProtocol = object()
wrap = FakeWrappedProto()
proto = defer.succeed(wrap)
class FakeSocks5(object):
def __init__(self, *args, **kw):
pass
def connect(self, *args, **kw):
return proto
ep_mock.side_effect = FakeSocks5
endpoint = TorClientEndpoint(
"torproject.org", 0, socks_endpoint=clientFromString(Mock(), "tcp:localhost:9050"), tls=True
)
p2 = yield endpoint.connect(None)
self.assertTrue(wrap.wrappedProtocol is p2)
def __init__(self, request, config):
self.request = request
self.config = config
factory = LDAPFactory()
endpoint = clientFromString(reactor, self.config['client'])
d = endpoint.connect(factory)
d.addCallback(self.gotConnection)
def _try_to_connect(reactor, endpoint_desc, stdout, txtorcon):
# yields a TorState, or None
ep = clientFromString(reactor, endpoint_desc)
d = txtorcon.build_tor_connection(ep)
def _failed(f):
# depending upon what's listening at that endpoint, we might get
# various errors. If this list is too short, we might expose an
# exception to the user (causing "tahoe create-node" to fail messily)
# when we're supposed to just try the next potential port instead.
# But I don't want to catch everything, because that may hide actual
# coding errrors.
f.trap(ConnectionRefusedError, # nothing listening on TCP
ConnectError, # missing unix socket, or permission denied
#ValueError,
# connecting to e.g. an HTTP server causes an
# UnhandledException (around a ValueError) when the handshake
# fails to parse, but that's not something we can catch. The
# attempt hangs, so don't do that.
RuntimeError, # authentication failure
)
if stdout:
stdout.write("Unable to reach Tor at '%s': %s\n" %
(endpoint_desc, f.value))
return None
d.addErrback(_failed)
return d
def _make_i2p_handler(self):
enabled = self.get_config("i2p", "enabled", True, boolean=True)
if not enabled:
return None
i2p = _import_i2p()
if not i2p:
return None
samport = self.get_config("i2p", "sam.port", None)
launch = self.get_config("i2p", "launch", False, boolean=True)
configdir = self.get_config("i2p", "i2p.configdir", None)
if samport:
if launch:
raise ValueError("tahoe.cfg [i2p] must not set both "
"sam.port and launch")
ep = endpoints.clientFromString(reactor, samport)
return i2p.sam_endpoint(ep)
if launch:
executable = self.get_config("i2p", "i2p.executable", None)
return i2p.launch(i2p_configdir=configdir, i2p_binary=executable)
if configdir:
return i2p.local_i2p(configdir)
return i2p.default(reactor)
def _parseSAMServer(self, reactor, keyfile, port, samEndpoint,
nickname=None,
autoClose=False,
options=None):
return SAMI2PStreamServerEndpoint.new(
clientFromString(reactor, samEndpoint),
keyfile, port, nickname, autoClose, options)
def _connect(self, reactor, update_status):
# create a new Tor
config = self.config = txtorcon.TorConfig()
if self._data_directory:
# The default is for launch_tor to create a tempdir itself, and
# delete it when done. We only need to set a DataDirectory if we
# want it to be persistent. This saves some startup time, because
# we cache the descriptors from last time. On one of my hosts,
# this reduces connect from 20s to 15s.
if not os.path.exists(self._data_directory):
# tor will mkdir this, but txtorcon wants to chdir to it
# before spawning the tor process, so (for now) we need to
# mkdir it ourselves. TODO: txtorcon should take
# responsibility for this.
os.mkdir(self._data_directory)
config.DataDirectory = self._data_directory
#config.ControlPort = allocate_tcp_port() # defaults to 9052
config.SocksPort = allocate_tcp_port()
socks_desc = "tcp:127.0.0.1:%d" % config.SocksPort
self._socks_desc = socks_desc # stash for tests
socks_endpoint = clientFromString(reactor, socks_desc)
with add_context(update_status, "launching Tor"):
tpp = yield txtorcon.launch_tor(config, reactor,
tor_binary=self._tor_binary)
#print "launched"
# gives a TorProcessProtocol with .tor_protocol
self._tor_protocol = tpp.tor_protocol
returnValue(socks_endpoint)
def get_i2p_handler(self):
enabled = self._get_i2p_config("enabled", True, boolean=True)
if not enabled:
return None
if not self._i2p:
return None
sam_port = self._get_i2p_config("sam.port", None)
launch = self._get_i2p_config("launch", False, boolean=True)
configdir = self._get_i2p_config("i2p.configdir", None)
keyfile = self._get_i2p_config("dest.private_key_file", None)
if sam_port:
if launch:
raise ValueError("tahoe.cfg [i2p] must not set both "
"sam.port and launch")
ep = clientFromString(self._reactor, sam_port)
return self._i2p.sam_endpoint(ep, keyfile=keyfile)
if launch:
executable = self._get_i2p_config("i2p.executable", None)
return self._i2p.launch(i2p_configdir=configdir,
i2p_binary=executable)
if configdir:
return self._i2p.local_i2p(configdir)
return self._i2p.default(self._reactor, keyfile=keyfile)
def test_tls_socks_with_endpoint(self, ep_mock):
"""
Same as above, except we provide an explicit endpoint
"""
the_proto = object()
proto_d = defer.succeed(the_proto)
class FakeSocks5(object):
def __init__(self, *args, **kw):
pass
def connect(self, *args, **kw):
return proto_d
def _get_address(self):
return defer.succeed(None)
ep_mock.side_effect = FakeSocks5
endpoint = TorClientEndpoint(
u'torproject.org', 0,
socks_endpoint=clientFromString(Mock(), "tcp:localhost:9050"),
tls=True,
)
p2 = yield endpoint.connect(None)
self.assertTrue(p2 is the_proto)
def get_i2p_handler(self):
enabled = self._get_i2p_config("enabled", True, boolean=True)
if not enabled:
return None
if not self._i2p:
return None
sam_port = self._get_i2p_config("sam.port", None)
launch = self._get_i2p_config("launch", False, boolean=True)
configdir = self._get_i2p_config("i2p.configdir", None)
keyfile = self._get_i2p_config("dest.private_key_file", None)
if sam_port:
if launch:
raise ValueError("tahoe.cfg [i2p] must not set both "
"sam.port and launch")
ep = clientFromString(self._reactor, sam_port)
return self._i2p.sam_endpoint(ep, keyfile=keyfile)
if launch:
executable = self._get_i2p_config("i2p.executable", None)
return self._i2p.launch(i2p_configdir=configdir, i2p_binary=executable)
if configdir:
return self._i2p.local_i2p(configdir)
return self._i2p.default(self._reactor, keyfile=keyfile)
def main():
"""
Just start all 3 protos
"""
# WS listener
ws_factory = WebSocketServerFactory(u"ws://52.34.209.113:8000")
ws_factory.protocol = WSProto
reactor.listenTCP(8000, ws_factory)
# MQTT listener
mqtt_factory = MQTTFactory(profile=MQTTFactory.SUBSCRIBER)
mqtt_endpoint = clientFromString(reactor, BROKER)
mqtt_serv = MQTTProto(mqtt_endpoint, mqtt_factory)
mqtt_serv.startService()
# CoAP listener
coap_root = resource.CoAPResource()
coap_ovh = CoAPProto()
coap_root.putChild('test', coap_ovh)
coap_endpoint = resource.Endpoint(coap_root)
reactor.listenUDP(coap.COAP_PORT, coap.Coap(coap_endpoint))
# run the program
reactor.run()
def test_socks_endpoint_real(self):
tor_socks_endpoint = clientFromString(reactor, "tcp:socks_host:100")
h = tor.socks_endpoint(tor_socks_endpoint)
res = yield h.hint_to_endpoint("tcp:example.com:1234", reactor)
ep, host = res
self.assertIsInstance(ep, txtorcon.endpoints.TorClientEndpoint)
self.assertEqual(host, "example.com")
def __init__(self,
desc,
nickname='cassbot',
init_channels=(),
reactor=None,
statefile=None):
service.MultiService.__init__(self)
self.statefile = statefile or self.default_statefile
self.state = {
'nickname': nickname,
'channels': init_channels,
'cmd_prefix': None,
'plugins': {},
}
self.auth = AuthMap()
if reactor is None:
from twisted.internet import reactor
self.reactor = reactor
self.endpoint_desc = desc
self.endpoint = endpoints.clientFromString(reactor, desc)
self.watcher_map = {}
self.command_map = {}
self.scanning_now = False
# all 'enabled' or 'loaded' plugins have an entry in here, keyed by
# the plugin name (as given by the .name() classmethod).
self.pluginmap = {}
self.pfactory = CassBotFactory()
def _connect(self, reactor, update_status):
maker = self._tor_control_endpoint_maker
with add_context(update_status, "making Tor control endpoint"):
tor_control_endpoint = yield maker(reactor, update_status)
assert IStreamClientEndpoint.providedBy(tor_control_endpoint)
with add_context(update_status, "connecting to Tor"):
tproto = yield txtorcon.build_tor_connection(tor_control_endpoint,
build_state=False)
with add_context(update_status, "waiting for Tor bootstrap"):
config = yield txtorcon.TorConfig.from_protocol(tproto)
ports = list(config.SocksPort)
# I've seen "9050", and "unix:/var/run/tor/socks WorldWritable"
for port in ports:
pieces = port.split()
p = pieces[0]
if p == txtorcon.DEFAULT_VALUE:
p = "9050"
try:
portnum = int(p)
socks_desc = "tcp:127.0.0.1:%d" % portnum
self._socks_desc = socks_desc # stash for tests
socks_endpoint = clientFromString(reactor, socks_desc)
returnValue(socks_endpoint)
except ValueError:
pass
raise ValueError("could not use config.SocksPort: %r" % (ports,))
def test_ssl(self):
"""
When passed an SSL strports description, L{clientFromString} returns a
L{SSL4ClientEndpoint} instance initialized with the values from the
string.
"""
reactor = object()
client = endpoints.clientFromString(
reactor, "ssl:host=example.net:port=4321:privateKey=%s:"
"certKey=%s:bindAddress=10.0.0.3:timeout=3:caCertsDir=%s" %
(escapedPEMPathName, escapedPEMPathName, escapedCAsPathName))
self.assertIsInstance(client, endpoints.SSL4ClientEndpoint)
self.assertIdentical(client._reactor, reactor)
self.assertEqual(client._host, "example.net")
self.assertEqual(client._port, 4321)
self.assertEqual(client._timeout, 3)
self.assertEqual(client._bindAddress, "10.0.0.3")
certOptions = client._sslContextFactory
self.assertIsInstance(certOptions, CertificateOptions)
ctx = certOptions.getContext()
self.assertIsInstance(ctx, ContextType)
self.assertEqual(Certificate(certOptions.certificate), testCertificate)
privateCert = PrivateCertificate(certOptions.certificate)
privateCert._setPrivateKey(KeyPair(certOptions.privateKey))
self.assertEqual(privateCert, testPrivateCertificate)
expectedCerts = [
Certificate.loadPEM(x.getContent()) for x in
[casPath.child("thing1.pem"),
casPath.child("thing2.pem")]
if x.basename().lower().endswith('.pem')
]
self.assertEqual(
sorted((Certificate(x) for x in certOptions.caCerts),
key=lambda cert: cert.digest()),
sorted(expectedCerts, key=lambda cert: cert.digest()))
def setup_connection(reactor, args):
"""
Return Cassandra connection
"""
return CQLClient(
clientFromString(reactor, 'tcp:{}:{}'.format(args.host, args.port)),
args.keyspace)
def connectionMade(self):
logger.info('[%s] Connection received from VNC client', self.id)
factory = protocol.ClientFactory()
factory.protocol = VNCProxyClient
factory.vnc_server = self
factory.deferrable = defer.Deferred()
endpoint = endpoints.clientFromString(reactor,
self.factory.vnc_address)
def _established_callback(client):
if self._broken:
client.close()
self.vnc_client = client
self.flush()
def _established_errback(reason):
logger.error(
'[VNCProxyServer] Connection succeeded but could not establish session: %s',
reason)
self.close()
factory.deferrable.addCallbacks(_established_callback,
_established_errback)
def _connect_errback(reason):
logger.error('[VNCProxyServer] Connection failed: %s', reason)
self.close()
endpoint.connect(factory).addErrback(_connect_errback)
self.send_ProtocolVersion_Handshake()
def __init__(self, live=False, retryPolicy=None,
clock=None, prepareConnection=None):
host = "ssl:" + (self.PROXY_LIVE if live else self.PROXY_DEMO)
endpoint = clientFromString(reactor, host)
factory = Client.Factory.forProtocol(Client.Protocol, client=self)
super().__init__(endpoint, factory, retryPolicy=retryPolicy,
clock=clock, prepareConnection=prepareConnection)
def clean(self, value):
from twisted.internet.endpoints import clientFromString
from twisted.internet import reactor
try:
return clientFromString(reactor, value)
except ValueError:
self.raise_config_error('is not a valid client endpoint')
def _make_control_endpoint(self, reactor, update_status):
# this will only be called when tahoe.cfg has "[tor] launch = true"
update_status("launching Tor")
with self._tor.add_context(update_status, "launching Tor"):
(endpoint_desc, _) = yield self._get_launched_tor(reactor)
tor_control_endpoint = clientFromString(reactor, endpoint_desc)
returnValue(tor_control_endpoint)
def get_client_endpoint(self):
"""
Get an ``IStreamClientEndpoint`` which will set up a connection to an I2P
address.
If I2P is not enabled or the dependencies are not available, return
``None`` instead.
"""
enabled = self._get_i2p_config("enabled", True, boolean=True)
if not enabled:
return None
if not self._i2p:
return None
sam_port = self._get_i2p_config("sam.port", None)
launch = self._get_i2p_config("launch", False, boolean=True)
configdir = self._get_i2p_config("i2p.configdir", None)
keyfile = self._get_i2p_config("dest.private_key_file", None)
if sam_port:
if launch:
raise ValueError("tahoe.cfg [i2p] must not set both "
"sam.port and launch")
ep = clientFromString(self._reactor, sam_port)
return self._i2p.sam_endpoint(ep, keyfile=keyfile)
if launch:
executable = self._get_i2p_config("i2p.executable", None)
return self._i2p.launch(i2p_configdir=configdir,
i2p_binary=executable)
if configdir:
return self._i2p.local_i2p(configdir)
return self._i2p.default(self._reactor, keyfile=keyfile)
def test_parser_basic(self):
ep = clientFromString(None, "tor:host=timaq4ygg2iegci7.onion:port=80:socksPort=9050")
self.assertEqual(ep.host, "timaq4ygg2iegci7.onion")
self.assertEqual(ep.port, 80)
# XXX what's "the Twisted way" to get the port out here?
self.assertEqual(ep.socks_endpoint._port, 9050)
def _try_to_connect(reactor, endpoint_desc, stdout, txi2p):
# yields True or None
ep = clientFromString(reactor, endpoint_desc)
d = txi2p.testAPI(reactor, 'SAM', ep)
def _failed(f):
# depending upon what's listening at that endpoint, we might get
# various errors. If this list is too short, we might expose an
# exception to the user (causing "tahoe create-node" to fail messily)
# when we're supposed to just try the next potential port instead.
# But I don't want to catch everything, because that may hide actual
# coding errors.
f.trap(
ConnectionRefusedError, # nothing listening on TCP
ConnectError, # missing unix socket, or permission denied
#ValueError,
# connecting to e.g. an HTTP server causes an
# UnhandledException (around a ValueError) when the handshake
# fails to parse, but that's not something we can catch. The
# attempt hangs, so don't do that.
RuntimeError, # authentication failure
)
if stdout:
stdout.write("Unable to reach I2P SAM API at '%s': %s\n" %
(endpoint_desc, f.value))
return None
d.addErrback(_failed)
return d
def _make_control_endpoint(self, reactor, update_status):
# this will only be called when tahoe.cfg has "[tor] launch = true"
update_status("launching Tor")
with self._tor.add_context(update_status, "launching Tor"):
(endpoint_desc, _) = yield self._get_launched_tor(reactor)
tor_control_endpoint = clientFromString(reactor, endpoint_desc)
returnValue(tor_control_endpoint)
def connect_to_exchange(self):
"""
Connect to an AMQP exchange as a publisher.
"""
exchange = self.pub_exchange
vhost = self.pub_vhost
user = self.pub_user
passwd = self.pub_passwd
endpoint_s = self.pub_endpoint_s
spec = self.pub_spec
e = clientFromString(self.reactor, endpoint_s)
delegate = TwistedDelegate()
amqp_protocol = AMQClient(
delegate=delegate,
vhost=vhost,
spec=spec)
try:
conn = yield connectProtocol(e, amqp_protocol)
except Exception:
self.log.failure(
"Failed to establish AMQP connection to endpoint '{0}'".format(
endpoint_s))
raise
yield conn.authenticate(user, passwd)
self.pub_channel = yield conn.channel(1)
yield self.pub_channel.channel_open()
def connectionMade(self):
# print("EndpointForwardingProtocol.connectionMade")
self._destFactory = DestEndpointForwardingFactory(self)
self._destEndpoint = clientFromString(
self.factory.service._reactor, self.factory.service._destEndpointDescriptor
)
self._destEndpointPort = yield self._destEndpoint.connect(self._destFactory)
def test_one_happy_one_jilted(self):
ep = clientFromString(reactor, self.transit)
a1 = yield connectProtocol(ep, Accumulator())
a2 = yield connectProtocol(ep, Accumulator())
token1 = b"\x00" * 32
side1 = b"\x01" * 8
side2 = b"\x02" * 8
a1.transport.write(b"please relay " + hexlify(token1) + b" for side " +
hexlify(side1) + b"\n")
while not self._transit_server._pending_requests:
yield wait() # make sure a1 connects first
a2.transport.write(b"please relay " + hexlify(token1) + b" for side " +
hexlify(side2) + b"\n")
while not self._transit_server._active_connections:
yield wait() # wait for the server to see the connection
self.assertEqual(len(self._transit_server._pending_requests), 0)
self.assertEqual(self._usage, []) # no events yet
a1.transport.write(b"\x00" * 13)
yield a2.waitForBytes(13)
a2.transport.write(b"\xff" * 7)
yield a1.waitForBytes(7)
a1.transport.loseConnection()
yield a1._disconnect
while self._transit_server._active_connections:
yield wait()
yield a2._disconnect
self.assertEqual(len(self._usage), 1, self._usage)
(started, result, total_bytes, total_time,
waiting_time) = self._usage[0]
self.assertEqual(result, "happy", self._usage)
self.assertEqual(total_bytes, 20)
self.assertNotIdentical(waiting_time, None)
def test_system_tor(self):
from test_torconfig import FakeControlProtocol
def boom(*args):
# why does the new_callable thing need a callable that
# returns a callable? Feels like I must be doing something
# wrong somewhere...
def bam(*args, **kw):
return self.protocol
return bam
with patch('txtorcon.endpoints.launch_tor') as launch_mock:
with patch('txtorcon.endpoints.build_tor_connection', new_callable=boom) as btc:
client = clientFromString(
self.reactor,
"tcp:host=localhost:port=9050"
)
ep = yield TCPHiddenServiceEndpoint.system_tor(self.reactor,
client, 80)
port = yield ep.listen(NoOpProtocolFactory())
toa = port.getHost()
self.assertTrue(hasattr(toa, 'onion_uri'))
self.assertTrue(hasattr(toa, 'onion_port'))
port.startListening()
str(port)
port.tor_config
# system_tor should be connecting to a running one,
# *not* launching a new one.
self.assertFalse(launch_mock.called)
def test_both_unsided(self):
ep = clientFromString(reactor, self.transit)
a1 = yield connectProtocol(ep, Accumulator())
a2 = yield connectProtocol(ep, Accumulator())
token1 = b"\x00" * 32
a1.transport.write(b"please relay " + hexlify(token1) + b"\n")
a2.transport.write(b"please relay " + hexlify(token1) + b"\n")
# a correct handshake yields an ack, after which we can send
exp = b"ok\n"
yield a1.waitForBytes(len(exp))
self.assertEqual(a1.data, exp)
s1 = b"data1"
a1.transport.write(s1)
exp = b"ok\n"
yield a2.waitForBytes(len(exp))
self.assertEqual(a2.data, exp)
# all data they sent after the handshake should be given to us
exp = b"ok\n" + s1
yield a2.waitForBytes(len(exp))
self.assertEqual(a2.data, exp)
a1.transport.loseConnection()
a2.transport.loseConnection()
def test_impatience_new_slow(self):
ep = clientFromString(reactor, self.transit)
a1 = yield connectProtocol(ep, Accumulator())
# For full coverage, we need dataReceived to see a particular framing
# of these two pieces of data, and ITCPTransport doesn't have flush()
# (which probably wouldn't work anyways). For now, force a 100ms
# stall between the two writes. I tried setTcpNoDelay(True) but it
# didn't seem to help without the stall. The long-term fix is to
# rewrite dataReceived() to remove the multiple "impatient"
# codepaths, deleting the particular clause that this test exercises,
# then remove this test.
token1 = b"\x00" * 32
side1 = b"\x01" * 8
# sending too many bytes is impatience.
a1.transport.write(b"please relay " + hexlify(token1) + b" for side " +
hexlify(side1) + b"\n")
d = defer.Deferred()
reactor.callLater(0.1, d.callback, None)
yield d
a1.transport.write(b"NOWNOWNOW")
exp = b"impatient\n"
yield a1.waitForBytes(len(exp))
self.assertEqual(a1.data, exp)
a1.transport.loseConnection()
def main(reactor, args):
endpoint_str = args.endpoint
e = clientFromString(reactor, endpoint_str)
d = connectProtocol(e, LDAPClient())
d.addCallback(onConnect, args)
d.addErrback(onError)
return d
def main(reactor, args):
vhost = args.vhost
user = args.user
passwd_file = args.passwd_file
if passwd_file is None:
passwd = 'guest'
else:
passwd = passwd_file.read().rstrip("\n\r")
passwd_file.close()
spec_path = os.path.join(
os.path.dirname(__file__),
'spec/amqp0-9-1.stripped.xml')
spec = txamqp.spec.load(spec_path)
params = {
'creds': (user, passwd),
'exchange': args.exchange,
'content': args.msg_file.read(),
'route_key': args.route_key,
}
endpoint_s = args.endpoint
e = clientFromString(reactor, endpoint_s)
delegate = TwistedDelegate()
amqp_protocol = AMQClient(
delegate=delegate,
vhost=vhost,
spec=spec)
d = connectProtocol(e, amqp_protocol)
d.addCallback(on_amqp_connect, params)
return d
def main(reactor, procName, *args):
clientEndpoints = {}
for k, v in os.environ.iteritems():
_, _, clientName = k.partition('client_endpoint_')
if clientName:
clientEndpoints[clientName] = clientFromString(reactor, v)
if not clientEndpoints:
raise ValueError("no client endpoints detected in the environment")
plugins = [pluginClass(clientEndpoints)
for pluginClass in sorted(pluginClasses, key=nameLength, reverse=True)]
if args == ('suggest',):
suggestions = []
for plugin in plugins:
suggestions.extend(plugin.name + arg for arg in plugin.suggest())
print '\n'.join(suggestions)
return defer.succeed(None)
procName = os.path.basename(procName)
for plugin in plugins:
_, foundPluginName, arg = procName.partition(plugin.name)
if not foundPluginName:
continue
command = 'fetch' if not args else args[0]
method = getattr(plugin, 'command_' + command, None)
if not method:
raise ValueError("%r plugin can't handle the command %r" % (plugin.name, command))
return defer.maybeDeferred(method, arg)
raise ValueError("no plugin was found with the name %r" % (procName,))
def _connect(self):
deferreds = []
for i, remote in enumerate(self.remotes):
d = defer.Deferred()
deferreds.append(d)
factory = vnc_client.client_factory(d, self.error_buffer)
factory.rewarder_session = self
factory.label = 'vnc:{}:{}'.format(i, remote)
endpoint = endpoints.clientFromString(reactor, 'tcp:' + remote)
def success(i):
logger.info('[%s] VNC connection established', factory.label)
def fail(reason):
reason = error.Error('[{}] Connection failed: {}'.format(
factory.label, reason.value))
try:
d.errback(utils.format_error(reason))
except defer.AlreadyCalledError:
pass
endpoint.connect(factory).addCallback(success).addErrback(fail)
d = defer.DeferredList(deferreds, fireOnOneErrback=True)
def success(results):
# Store the _clients list when connected
self._clients = [client for success, client in results]
d.addCallback(success)
return d
def main(self, reactor, description):
endpoint = endpoints.clientFromString(reactor, description)
factory = AkumaBotFactory(self.config)
d = endpoint.connect(factory)
d.addCallback(self.got_protocol)
d.addCallback(lambda protocol: protocol.deferred)
return d
def test_startServer(self):
"""
Should call twisted.internet.endpoints.serverFromString and hook that
up to the factory
"""
h = Hub()
h.remote_echo = lambda x: x
h.startServer(h.getPBServerFactory(), 'tcp:10999')
# connect to it
self.clientPort = None
client = clientFromString(reactor, 'tcp:host=127.0.0.1:port=10999')
factory = pb.PBClientFactory()
d = client.connect(factory)
def saveClient(clientPort):
self.clientPort = clientPort
d.addCallback(saveClient)
d.addCallback(lambda ign: factory.getRootObject())
d.addCallback(lambda obj: obj.callRemote('echo', 'foo'))
d.addCallback(lambda res: self.assertEqual(res, 'foo'))
d.addCallback(lambda ign: self.clientPort.transport.loseConnection())
d.addCallback(lambda ign: h.stopServer('tcp:10999'))
return d
def _connect_to_daemon(self):
"""Connect to the daemon so that we can receive events."""
description = 'unix:path=%s' % DAEMON_SOCKET
client = endpoints.clientFromString(reactor, description)
self._protocol = yield client.connect(self._factory)
# add the user with no paths
yield self._protocol.add_user([])
def buildClientEndpoint(self, params):
if not params.get('endpoint'):
ep = "tcp:host=%s:port=%s" % (params['host'], params['port'])
else:
assert not params.get('host')
assert not params.get('port')
ep = params['endpoint']
return endpoints.clientFromString(reactor, ep)
def main(reactor):
log.startLogging(sys.stdout)
endpoint_str = "tcp:host=localhost:port=8080"
e = clientFromString(reactor, endpoint_str)
d = connectProtocol(e, LDAPClient())
d.addCallback(onConnect)
d.addErrback(onError, reactor)
return d
